Differential D14050 Diff 38973 libdiscover/backends/FwupdBackend/FwupdBackend.cpp

Changeset View

Standalone View

View Options

libdiscover/backends/FwupdBackend/FwupdBackend.cpp

  • This file was added.
1​/***************************************************************************
2​ * Copyright © 2013 Aleix Pol Gonzalez <aleixpol@blue-systems.com> *
3​ * Copyright © 2018 Abhijeet Sharma <sharma.abhijeet2096@gmail.com> *
4​ * *
5​ * This program is free software; you can redistribute it and/or *
6​ * modify it under the terms of the GNU General Public License as *
7​ * published by the Free Software Foundation; either version 2 of *
8​ * the License or (at your option) version 3 or any later version *
9​ * accepted by the membership of KDE e.V. (or its successor approved *
10​ * by the membership of KDE e.V.), which shall act as a proxy *
11​ * defined in Section 14 of version 3 of the license. *
12​ * *
13​ * This program is distributed in the hope that it will be useful, *
14​ * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15​ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16​ * GNU General Public License for more details. *
17​ * *
18​ * You should have received a copy of the GNU General Public License *
19​ * along with this program. If not, see <http://www.gnu.org/licenses/>. *
20​ ***************************************************************************/
21​
22​#include "FwupdBackend.h"
23​#include "FwupdResource.h"
24​#include "FwupdTransaction.h"
25​#include "FwupdSourcesBackend.h"
26​#include <resources/StandardBackendUpdater.h>
27​#include <resources/SourcesModel.h>
28​#include <Transaction/Transaction.h>
29​
30​#include <KAboutData>
31​#include <KLocalizedString>
32​#include <KPluginFactory>
33​#include <KConfigGroup>
34​#include <KSharedConfig>
35​
36​DISCOVER_BACKEND_PLUGIN(FwupdBackend)
37​
38​FwupdBackend::FwupdBackend(QObject* parent)
39​ : AbstractResourcesBackend(parent)
40​ , m_updater(new StandardBackendUpdater(this))
41​ , m_fetching(true)
42​{
43​
44​ QTimer::singleShot(500, this, &FwupdBackend::toggleFetching);
45​ connect(m_updater, &StandardBackendUpdater::updatesCountChanged, this, &FwupdBackend::updatesCountChanged);
46​
47​ client = fwupd_client_new ();
48​
49​ populate(QStringLiteral("Releases"));
50​ SourcesModel::global()->addSourcesBackend(new FwupdSourcesBackend(this));
51​}
52​
53​QMap<GChecksumType, QCryptographicHash::Algorithm> FwupdBackend::initHashMap()
54​{
55​ QMap<GChecksumType,QCryptographicHash::Algorithm> map;
56​
57​ map.insert(G_CHECKSUM_SHA1,QCryptographicHash::Sha1);
58​ map.insert(G_CHECKSUM_SHA256,QCryptographicHash::Sha256);
59​ map.insert(G_CHECKSUM_SHA512,QCryptographicHash::Sha512);
60​ map.insert(G_CHECKSUM_MD5,QCryptographicHash::Md5);
61​
62​ return map;
63​}
64​
65​FwupdBackend::~FwupdBackend()
66​{
67​ g_object_unref (client);
68​}
69​
anthonyfieroniUnsubmitted
Done

Indentations should be 4 spaces, if statement goes with { on same line and } even on one line body.

anthonyfieroni: Indentations should be 4 spaces, if statement goes with { on same line and } even on one line…
70​QString FwupdBackend::buildDeviceID(FwupdDevice* device)
71​{
72​ QString DeviceID = QString::fromUtf8(fwupd_device_get_id (device));
73​ DeviceID.replace(QLatin1Char('/'),QLatin1Char('_'));
74​ return QStringLiteral("org.fwupd.%1.device").arg(DeviceID);
75​}
76​
77​void FwupdBackend::addResourceToList(FwupdResource* res)
78​{
79​ res->setState(FwupdResource::Upgradeable);
80​ m_resources.insert(res->packageName().toLower(), res);
81​}
82​
83​FwupdResource * FwupdBackend::createDevice(FwupdDevice *device)
84​{
85​ const QString name = QString::fromUtf8(fwupd_device_get_name(device));
86​ FwupdResource* res = new FwupdResource(name, true, this);
anthonyfieroniUnsubmitted
Not Done

It's memory leak.

anthonyfieroni: It's memory leak.
abhijeet2096AuthorUnsubmitted
Not Done

Please see the new modified function. Will Memory be leaking?

abhijeet2096: Please see the new modified function. Will Memory be leaking?
apolUnsubmitted
Done

When getting a string from glib, use QString::fromUtf8, which is what I guess they use.

apol: When getting a string from glib, use QString::fromUtf8, which is what I guess they use.
87​ res->setId(buildDeviceID(device));
88​ res->addCategories(QStringLiteral("Releases"));
89​ res->setIconName(QString::fromUtf8((const gchar *)g_ptr_array_index (fwupd_device_get_icons(device),0)));// Implement a Better way to decide icon
90​
91​ setDeviceDetails(res,device);
92​ return res;
93​}
94​
apolUnsubmitted
Done

Does it still make sense to add it if it doesn't have an id?
In which cases wouldn't it have an id?

apol: Does it still make sense to add it if it doesn't have an id? In which cases wouldn't it have an…
95​FwupdResource * FwupdBackend::createRelease(FwupdDevice *device)
96​{
97​ FwupdRelease *rel = fwupd_device_get_release_default (device);
98​ const QString name = QString::fromUtf8(fwupd_release_get_name(rel));
99​ FwupdResource* res = new FwupdResource(name, true, this);
100​
101​ res->setDeviceID(QString::fromUtf8(fwupd_device_get_id (device)));
apolUnsubmitted
Done

No need to cast. Use the FwupdResource directly.

apol: No need to cast. Use the FwupdResource directly.
abhijeet2096AuthorUnsubmitted
Done

Still Need To Fix it

abhijeet2096: Still Need To Fix it
102​ setReleaseDetails(res,rel);
103​ setDeviceDetails(res,device);
104​
105​ if (fwupd_release_get_appstream_id (rel))
106​ res->setId(QString::fromUtf8(fwupd_release_get_appstream_id (rel)));
107​
108​ /* the same as we have already */
109​ if(QLatin1Literal(fwupd_device_get_version (device)) == QLatin1Literal(fwupd_release_get_version (rel)))
110​ {
111​ qWarning() << "Fwupd Error: same firmware version as installed";
112​ }
113​
114​ return res;
115​
116​}
117​void FwupdBackend::setReleaseDetails(FwupdResource *res, FwupdRelease *rel)
118​{
119​ res->addCategories(QLatin1String("Releases"));
120​ if(fwupd_release_get_summary(rel))
121​ res->setSummary(QString::fromUtf8(fwupd_release_get_summary(rel)));
122​ if(fwupd_release_get_vendor(rel))
123​ res->setVendor(QString::fromUtf8(fwupd_release_get_vendor(rel)));
124​ if(fwupd_release_get_version(rel))
125​ res->setVersion(QString::fromUtf8(fwupd_release_get_version(rel)));
126​ if(fwupd_release_get_description(rel))
127​ res->setDescription(QString::fromUtf8((fwupd_release_get_description (rel))));
128​ if(fwupd_release_get_homepage(rel))
129​ res->setHomePage(QUrl(QString::fromUtf8(fwupd_release_get_homepage(rel))));
130​ if(fwupd_release_get_license(rel))
131​ res->setLicense(QString::fromUtf8(fwupd_release_get_license(rel)));
132​ if (fwupd_release_get_uri (rel))
133​ res->m_updateURI = QString::fromUtf8(fwupd_release_get_uri (rel));
134​}
135​void FwupdBackend::setDeviceDetails(FwupdResource *res, FwupdDevice *dev)
136​{
137​ res->isLiveUpdatable = fwupd_device_has_flag (dev, FWUPD_DEVICE_FLAG_UPDATABLE);
138​ res->isOnlyOffline = fwupd_device_has_flag (dev, FWUPD_DEVICE_FLAG_ONLY_OFFLINE);
139​ res->needsReboot = fwupd_device_has_flag (dev, FWUPD_DEVICE_FLAG_NEEDS_REBOOT);
140​ res->isDeviceRemoval = !fwupd_device_has_flag (dev, FWUPD_DEVICE_FLAG_INTERNAL);
141​
142​ GPtrArray *guids = fwupd_device_get_guids (dev);
143​ if(guids->len > 0)
144​ {
145​ QString guidStr = QString::fromUtf8((char *)g_ptr_array_index (guids, 0));
146​ for (uint i = 1; i < guids->len; i++)
147​ {
148​ guidStr += QLatin1Char(',') + QString::fromUtf8((char *)g_ptr_array_index (guids, i));
149​ }
150​ res->guidString = guidStr;
151​ }
152​ if(fwupd_device_get_name (dev))
153​ {
154​ QString vendorName;
155​ vendorName.sprintf("%s",fwupd_device_get_name (dev));
156​
157​ if(vendorName.indexOf(QString::fromUtf8(fwupd_device_get_vendor (dev))) == 0)
158​ vendorName.sprintf("%s %s",fwupd_device_get_vendor (dev), fwupd_device_get_name (dev));
159​ res->setName(vendorName);
160​ }
161​ if(fwupd_device_get_summary (dev))
162​ res->setSummary(QString::fromUtf8(fwupd_device_get_summary(dev)));
163​ if(fwupd_device_get_vendor(dev))
164​ res->setVendor(QString::fromUtf8(fwupd_device_get_vendor(dev)));
apolUnsubmitted
Done

This is not a literal. Use QString::fromLatin1 (or fromUtf8, it should be Utf8).

apol: This is not a literal. Use QString::fromLatin1 (or fromUtf8, it should be Utf8).
165​ if(fwupd_device_get_version(dev))
166​ res->setVersion(QString::fromUtf8(fwupd_device_get_version(dev)));
167​ if(fwupd_device_get_description(dev))
168​ res->setDescription(QString::fromUtf8((fwupd_device_get_description(dev))));
apolUnsubmitted
Done

res->isLiveUpdatable = fwupd_device_has_flag (dev, FWUPD_DEVICE_FLAG_UPDATABLE)
And same with the rest.

apol: ` res->isLiveUpdatable = fwupd_device_has_flag (dev, FWUPD_DEVICE_FLAG_UPDATABLE)` And same…
169​}
170​
171​void FwupdBackend::populate(const QString& n)
172​{
173​ /* get devices */
174​ g_autoptr(GPtrArray) devices = fwupd_client_get_devices (client, nullptr, nullptr);
175​
176​ if (devices)
177​ {
178​ for (uint i = 0; i < devices->len; i++)
179​ {
180​ FwupdDevice *device = (FwupdDevice *)g_ptr_array_index (devices, i);
181​
182​ /* Devices Which are not updatable */
183​ if (!fwupd_device_has_flag (device, FWUPD_DEVICE_FLAG_UPDATABLE))
184​ continue;
185​
186​ /* add releases */
187​ FwupdResource * res = createDevice(device);
188​ res->addCategories(n);
189​
190​
191​ g_autoptr(GPtrArray) releases = fwupd_client_get_releases (client, res->m_deviceID.toUtf8().constData(), nullptr, nullptr);
192​
193​ if (releases)
194​ {
apolUnsubmitted
Done

Use QString, not g_* to construct strings.

apol: Use QString, not g_* to construct strings.
195​ for (uint j = 0; j < releases->len; j++)
196​ {
197​ FwupdRelease *rel = (FwupdRelease *)g_ptr_array_index (releases, j);
198​ const QString name = QString::fromUtf8(fwupd_release_get_name(rel));
199​ FwupdResource* res_ = new FwupdResource(name, true, this);
200​ setReleaseDetails (res_, rel);
201​ res->m_releases.append(res_);
202​ }
203​ }
204​ /* add all Valid Resources */
205​ m_resources.insert(res->packageName().toLower(), res);
206​ }
207​ }
208​}
209​
210​
apolUnsubmitted
Done

Just initialize at once. No need to set NULL first.

apol: Just initialize at once. No need to set NULL first.
211​void FwupdBackend::addUpdates()
212​{
213​ g_autoptr(GError) error = nullptr;
214​ g_autoptr(GError) error2 = nullptr;
215​ g_autoptr(GPtrArray) devices = fwupd_client_get_devices (client, nullptr, &error);
216​
217​ if(!devices)
218​ {
219​ if (g_error_matches (error, FWUPD_ERROR, FWUPD_ERROR_NOTHING_TO_DO))
220​ {
apolUnsubmitted
Done

Same

apol: Same
221​ qDebug() << "Fwupd Info: No Devices Found";
222​ handleError(&error);
223​ }
224​ }
apolUnsubmitted
Done

Usually name is a user-visible string. Would it make more sense to use packageName?
This way you could also skip the toLower part.

apol: Usually name is a user-visible string. Would it make more sense to use packageName? This way…
225​ else{
226​ for (uint i = 0; i < devices->len; i++)
227​ {
228​ FwupdDevice *device = (FwupdDevice *)g_ptr_array_index (devices, i);
229​ FwupdResource* res;
230​
231​ if (!fwupd_device_has_flag (device, FWUPD_DEVICE_FLAG_SUPPORTED))
232​ continue;
233​
234​ /*Device is Locked Needs Unlocking*/
apolUnsubmitted
Done

if (releases)

apol: `if (releases)`
235​ if (fwupd_device_has_flag (device, FWUPD_DEVICE_FLAG_LOCKED))
236​ {
apolUnsubmitted
Done

Use uint rather than casting

apol: Use uint rather than casting
237​ res = createDevice(device);
238​ res->setIsDeviceLocked(true);
239​ addResourceToList(res);
240​ connect(res, &FwupdResource::stateChanged, this, &FwupdBackend::updatesCountChanged);
241​ continue;
242​ }
apolUnsubmitted
Done

Remove ifdef, fix indentation

apol: Remove ifdef, fix indentation
243​
244​
245​ g_autoptr(GPtrArray) rels = fwupd_client_get_upgrades (client, fwupd_device_get_id(device), nullptr, &error2);
246​
247​ if (!rels)
248​ {
249​ if (g_error_matches (error2, FWUPD_ERROR, FWUPD_ERROR_NOTHING_TO_DO))
250​ {
251​ qWarning() << "Fwupd Error: No Packages Found for "<< fwupd_device_get_id(device);
252​ handleError(&error2);
253​ continue;
254​ }
255​ }
256​ else
257​ {
258​ fwupd_device_add_release(device, (FwupdRelease *)g_ptr_array_index(rels, 0));
259​ res = createApp(device);
260​ if(res == nullptr)
261​ {
262​ qWarning() << "Fwupd Error: Cannot Create App From Device";
apolUnsubmitted
Done

Don't initialize twice.

apol: Don't initialize twice.
263​ }
apolUnsubmitted
Done

if (devices)

apol: if (devices)
264​ else
265​ {
266​ if(rels->len > 1)
267​ {
268​ QString longdescription;
269​ for(uint j = 0; j < rels->len; j++)
270​ {
apolUnsubmitted
Done

} else {

apol: } else {
271​ FwupdRelease *rel = (FwupdRelease *)g_ptr_array_index (rels, j);
272​ if (fwupd_release_get_description (rel) == nullptr)
273​ continue;
274​ longdescription += QStringLiteral("Version %1\n").arg(QString::fromUtf8(fwupd_release_get_version (rel)));
275​ longdescription += QString::fromUtf8(fwupd_release_get_description (rel)) + QLatin1Char('\n');
276​ }
277​ res->setDescription(longdescription);
278​ }
279​ addResourceToList(res);
280​ }
281​ }
282​ }
283​ }
284​}
285​
286​void FwupdBackend::addHistoricalUpdates()
287​{
288​ g_autoptr(GError) error = nullptr;
289​ g_autoptr(FwupdDevice) device = fwupd_client_get_results (client, FWUPD_DEVICE_ID_ANY, nullptr, &error);
290​ if(!device)
zzagUnsubmitted
Done

Coding style nitpick: indentation is not consistent. At all.

zzag: Coding style nitpick: indentation is not consistent. At all.
291​ {
292​ handleError(&error);
293​ }
294​ else
295​ {
296​ FwupdResource* res = createRelease(device);
297​ if(!res)
298​ qWarning() << "Fwupd Error: Cannot Make App for" << fwupd_device_get_id(device);
299​ else
300​ {
301​ addResourceToList(res);
302​ }
303​ }
304​}
305​
306​
307​QByteArray FwupdBackend::getChecksum(const QUrl filename, QCryptographicHash::Algorithm hashAlgorithm)
308​{
309​ QFile f(filename.toString());
zzagUnsubmitted
Done

Coding style nitpick: why does this small piece of code follows several totally different coding styles?

zzag: Coding style nitpick: why does this small piece of code follows several totally different…
310​ if (f.open(QFile::ReadOnly))
311​ {
312​ QCryptographicHash hash(hashAlgorithm);
313​ if (hash.addData(&f))
314​ {
315​ return hash.result().toHex();
316​ }
317​ }
318​ return QByteArray();
319​}
320​
321​FwupdResource* FwupdBackend::createApp(FwupdDevice *device)
322​{
323​ FwupdRelease *rel = fwupd_device_get_release_default (device);
324​ GPtrArray *checksums;
325​ FwupdResource* app = createRelease(device);
326​
327​ /* update unsupported */
328​ if (!app->isLiveUpdatable)
329​ {
apolUnsubmitted
Done

Don't set to null only to initialize at the next line.

apol: Don't set to null only to initialize at the next line.
330​ qWarning() << "Fwupd Error: " << app->m_name << "[" << app->m_id << "]" << "cannot be updated ";
331​ return nullptr;
332​ }
333​
334​ /* Important Attributes missing */
335​ if (app->m_id.isNull())
336​ {
337​ qWarning() << "Fwupd Error: No id for firmware";
338​ return nullptr;
339​ }
340​ if (app->m_version.isNull())
341​ {
342​ qWarning() << "Fwupd Error: No version! for " << app->m_id;
343​ return nullptr;
344​ }
345​ if (app->m_updateVersion.isNull())
346​ {
347​ qWarning() << "Fwupd Error: No update-version! for " << app->m_id;
348​ return nullptr;
349​ }
350​ checksums = fwupd_release_get_checksums (rel);
351​ if (checksums->len == 0)
352​ {
353​ qWarning() << "Fwupd Error: " << app->m_name << "[" << app->m_id << "]" << "(" << app->m_updateVersion << ")" "has no checksums, ignoring as unsafe";
354​ return nullptr;
355​ }
356​ const QUrl update_uri(QString::fromUtf8(fwupd_release_get_uri(rel)));
357​
358​ if (!update_uri.isValid())
359​ {
360​ qWarning() << "Fwupd Error: No Update URI available for" << app->m_name << "[" << app->m_id << "]";
361​ return nullptr;
362​ }
363​
364​ /* Checking for firmware in the cache? */
365​ QFileInfo basename = QFileInfo(update_uri.path());
366​ const QUrl filename_cache = cacheFile(QStringLiteral("fwupd"), basename);
367​ if (filename_cache.isEmpty())
368​ return nullptr;
369​
370​ if (filename_cache.isLocalFile())
371​ {
372​ QByteArray checksum_tmp = QByteArray(fwupd_checksum_get_by_kind (checksums, G_CHECKSUM_SHA1));
373​
374​ /* Currently LVFS supports SHA1 only*/
375​ if (checksum_tmp.isNull())
376​ {
377​ qWarning() << "Fwupd Error: No valid checksum for" << filename_cache;
378​ }
379​ QByteArray checksum = getChecksum(filename_cache, QCryptographicHash::Sha1);
380​ if (checksum.isNull() || checksum_tmp.isNull())
381​ return nullptr;
382​ if (checksum_tmp != checksum)
383​ {
384​ qWarning() << "Fwupd Error: " << filename_cache << " does not match checksum, expected" << checksum_tmp << "got" << checksum;
385​ QFile::remove((filename_cache.toString()));
386​ return nullptr;
387​ }
388​ }
389​
390​ /* link file to application and return its reference */
391​ app->m_file = filename_cache.toString();
392​ return app;
393​}
394​
395​void FwupdBackend::saveFile(QNetworkReply *reply)
396​{
apolUnsubmitted
Not Done

Are you sure you need an event-loop there? Let's make this non-blocking.

apol: Are you sure you need an event-loop there? Let's make this non-blocking.
abhijeet2096AuthorUnsubmitted
Not Done

Can you please guide me, on how can I make this non-blocking?

abhijeet2096: Can you please guide me, on how can I make this non-blocking?
397​ QString filename = this->m_downloadFile[reply->url()];
apolUnsubmitted
Done

&file is in this scope, it will crash as soon as you call m_file outside this scope.

Maybe just keep the path?

apol: &file is in this scope, it will crash as soon as you call m_file outside this scope. Maybe…
398​ if (reply->error() == QNetworkReply::NoError)
399​ {
400​ QByteArray Data = reply->readAll();
401​ QFile file(filename);
402​ if (file.open(QIODevice::WriteOnly))
403​ {
404​ file.write(Data);
405​ }
406​ else
407​ {
408​ qWarning() << "Fwupd Error: Cannot Open File to write Data";
409​ }
410​ file.close();
411​ delete reply;
412​ }
apolUnsubmitted
Done

else { qWarning() ...

apol: else { qWarning() ...
413​}
414​
415​bool FwupdBackend::downloadFile(const QUrl &uri,const QString &filename)
416​{
417​ QNetworkAccessManager *manager = new QNetworkAccessManager(this);
418​ this->m_downloadFile.insert(uri,filename);
419​ QEventLoop loop;
420​ QTimer getTimer;
421​ connect(&getTimer, &QTimer::timeout, &loop, &QEventLoop::quit);
422​ connect(manager, &QNetworkAccessManager::finished, &loop, &QEventLoop::quit);
423​ QNetworkReply *reply = manager->get(QNetworkRequest(uri));
424​ getTimer.start(600000); // 60 Seconds TimeOout Period
425​ loop.exec();
426​ if(!reply)
427​ {
428​ return false;
429​ }
430​ else if( QNetworkReply::NoError != reply->error() )
431​ {
432​ return false;
433​ }
434​ else
435​ {
436​ saveFile(reply);
437​ delete manager;
438​ }
439​ return true;
440​}
441​
442​bool FwupdBackend::refreshRemotes(uint cacheAge)
443​{
444​ g_autoptr(GError) error = nullptr;
445​ g_autoptr(GPtrArray) remotes = fwupd_client_get_remotes(client, nullptr, &error);
446​ if (!remotes)
447​ return false;
448​ for (uint i = 0; i < remotes->len; i++)
449​ {
450​ FwupdRemote *remote = (FwupdRemote *)g_ptr_array_index(remotes, i);
451​ /*Remotes disabled by user so ignore*/
452​ if (!fwupd_remote_get_enabled (remote))
453​ continue;
454​ /*Local Remotes Ignore*/
455​ if (fwupd_remote_get_kind (remote) == FWUPD_REMOTE_KIND_LOCAL)
456​ continue;
457​ /*Refresh the left ones*/
458​ if (!refreshRemote(remote, cacheAge))
459​ return false;
460​ }
461​ return true;
462​}
463​
464​bool FwupdBackend::refreshRemote(FwupdRemote* remote, uint cacheAge)
465​{
apolUnsubmitted
Done

Use QFile

apol: Use QFile
466​ g_autoptr(GError) error = nullptr;
467​
468​ if (fwupd_remote_get_filename_cache_sig(remote) == nullptr)
469​ {
470​ qWarning() << "Fwupd Error: " << "Remote " << fwupd_remote_get_id (remote) << "has no cache signature!";
471​ return false;
472​ }
473​
474​ /* check cache age */
475​ if (cacheAge > 0)
476​ {
477​ quint64 age = fwupd_remote_get_age(remote);
478​ uint tmp = age < std::numeric_limits<uint>::max() ? (uint) age : std::numeric_limits<uint>::max();
479​ if (tmp < cacheAge)
480​ {
481​ qDebug() << "Fwupd Info:" << fwupd_remote_get_id (remote) << "is only" << tmp << "seconds old, so ignoring refresh! ";
482​ return true;
483​ }
apolUnsubmitted
Done

QUrl

apol: QUrl
484​ }
485​
486​ QString cacheId = QStringLiteral("fwupd/remotes.d/%1").arg(QString::fromUtf8(fwupd_remote_get_id (remote)));
487​ QFileInfo basenameSig = QFileInfo(QString::fromUtf8(g_path_get_basename(fwupd_remote_get_filename_cache_sig (remote))));
488​ const QUrl filenameSig = cacheFile(cacheId, basenameSig);
489​
490​ if (filenameSig.isEmpty())
491​ return false;
492​
493​ /* download the signature first*/
494​ const QUrl urlSig(QString::fromUtf8(fwupd_remote_get_metadata_uri_sig(remote)));
495​ qDebug() << "Fwupd Info: downloading remotes signatures ...";
496​
497​
498​ const QUrl filenameSig_(filenameSig.toString() + QStringLiteral(".tmp"));
499​
500​ if(!downloadFile(urlSig,filenameSig_.toString()))
501​ {
502​ qDebug() << "Fwupd Info: remote signature download failed ...";
503​ return false;
504​ }
505​
506​ QMap<GChecksumType,QCryptographicHash::Algorithm> map = initHashMap();
507​ QCryptographicHash::Algorithm hashAlgorithm = map[(fwupd_checksum_guess_kind(fwupd_remote_get_checksum(remote)))];
508​ QByteArray hash = getChecksum(filenameSig_,hashAlgorithm);
509​
510​ if ((fwupd_remote_get_checksum(remote) == hash) && filenameSig.isLocalFile())
511​ {
512​ qDebug() << "Fwupd Info: signature of" << urlSig.toString() << "is unchanged";
513​ return true;
514​ }
515​ else
516​ QFile::remove(filenameSig.toString());
517​
518​ /* save to a file */
519​ qDebug() << "Fwupd Info: saving new remote signature to:" << filenameSig.toString();
520​
521​ if (!(QFile::copy(filenameSig_.toString(), filenameSig.toString())))
522​ {
523​ QFile::remove(filenameSig_.toString());
524​ qWarning() << "Fwupd Error: cannot save remote signature";
525​ return false;
526​ }
527​ QFile::remove(filenameSig_.toString());
528​
529​ QFileInfo basename = QFileInfo(QString::fromUtf8(g_path_get_basename(fwupd_remote_get_filename_cache(remote))));
530​ const QUrl filename = cacheFile(cacheId, basename);
531​
532​ if (filename.isEmpty())
533​ return false;
534​
535​ qDebug() << "Fwupd Info: saving new firmware metadata to:" << filename.toString();
536​
537​ const QUrl url(QString::fromUtf8(fwupd_remote_get_metadata_uri(remote)));
538​ if (!downloadFile (url, filename.toString()))
539​ {
540​ qWarning() << "Fwupd Error: cannot download file : " << filename.toString() ;
541​ return false;
542​ }
543​ /* Sending Metadata to fwupd Daemon*/
544​ if (!fwupd_client_update_metadata (client, fwupd_remote_get_id(remote), filename.toString().toUtf8().constData(), filenameSig.toString().toUtf8().constData(), nullptr, &error))
545​ {
546​ handleError(&error);
547​ return false;
548​ }
549​ return true;
550​}
551​
552​void FwupdBackend::handleError(GError **perror)
553​{
554​ GError *error = perror != nullptr ? *perror : nullptr;
555​
556​ if(!error)
557​ return;
558​ switch (error->code)
559​ {
560​ case FWUPD_ERROR_ALREADY_PENDING:
561​ qWarning() << "Fwupd Error: FWUPD_ERROR_ALREADY_PENDING";
562​ Q_EMIT passiveMessage(i18n("FWUPD ERROR ALREADY PENDING!"));
563​ break;
564​ case FWUPD_ERROR_INVALID_FILE:
565​ qWarning() << "Fwupd Error: FWUPD_ERROR_INVALID_FILE";
566​ Q_EMIT passiveMessage(i18n("FWUPD ERROR INVALID FILE"));
567​ break;
568​ case FWUPD_ERROR_NOT_SUPPORTED:
569​ qWarning() << "Fwupd Error: FWUPD_ERROR_NOT_SUPPORTED";
570​ Q_EMIT passiveMessage(i18n("FWUPD ERROR NOT SUPPORTED"));
571​ break;
572​ case FWUPD_ERROR_AUTH_FAILED:
573​ qWarning() << "Fwupd Error: FWUPD_ERROR_AUTH_FAILED";
574​ Q_EMIT passiveMessage(i18n("FWUPD ERROR AUTH FAILED"));
575​ break;
576​ case FWUPD_ERROR_SIGNATURE_INVALID:
577​ qWarning() << "Fwupd Error: FWUPD_ERROR_SIGNATURE_INVALID";
578​ Q_EMIT passiveMessage(i18n("FWUPD ERROR SIGNATURE INVALID"));
579​ break;
580​ case FWUPD_ERROR_AC_POWER_REQUIRED:
581​ qWarning() << "Fwupd Error: FWUPD_ERROR_AC_POWER_REQUIRED";
582​ Q_EMIT passiveMessage(i18n("FWUPD ERROR AC POWER REQUIRED"));
583​ break;
584​ default:
585​ qWarning() << "Fwupd Error: Unknown Error " << error->code;
586​ break;
587​ }
588​}
589​
590​const QUrl FwupdBackend::cacheFile(const QString &kind,const QFileInfo &resource)
591​{
592​ QString basename = resource.fileName();
593​ const QDir cacheDir(QStandardPaths::writableLocation(QStandardPaths::CacheLocation));
594​ const QUrl cacheDirFile = QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::CacheLocation) + QLatin1Char('/') + kind);
595​ const QUrl fileUrl = QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::CacheLocation) + QLatin1Char('/') + kind + QLatin1Char('/') + basename);
596​
597​ if(!QFileInfo::exists(cacheDirFile.toLocalFile()) && !cacheDir.mkpath(kind))
598​ {
599​ qWarning() << "Fwupd Error: cannot make cache directory!";
600​ return QUrl();
601​ }
602​ return QUrl(fileUrl.toString().remove(QStringLiteral("file://")));
603​}
604​
605​void FwupdBackend::toggleFetching()
606​{
607​ m_fetching = !m_fetching;
608​ refreshRemotes(30*24*60*60); // Nicer Way to put time? currently 30 days in seconds
609​ addUpdates();
610​ addHistoricalUpdates();
611​ emit fetchingChanged();
612​}
613​
614​int FwupdBackend::updatesCount() const
615​{
616​ return m_updater->updatesCount();
617​}
618​
619​ResultsStream* FwupdBackend::search(const AbstractResourcesBackend::Filters& filter)
620​{
621​ QVector<AbstractResource*> ret;
622​ if (!filter.resourceUrl.isEmpty() && filter.resourceUrl.scheme() == QLatin1String("fwupd"))
623​ {
624​ return findResourceByPackageName(filter.resourceUrl);
625​ }
626​ else
627​ {
628​ foreach(AbstractResource* r, m_resources)
629​ {
630​ if(r->name().contains(filter.search, Qt::CaseInsensitive) || r->comment().contains(filter.search, Qt::CaseInsensitive))
631​ ret += r;
632​ }
633​ }
634​ return new ResultsStream(QStringLiteral("FwupdStream"), ret);
635​}
636​
637​ResultsStream * FwupdBackend::findResourceByPackageName(const QUrl& search)
638​{
639​ auto res = search.scheme() == QLatin1String("fwupd") ? m_resources.value(search.host().replace(QLatin1Char('.'), QLatin1Char(' '))) : nullptr;
640​ if (!res) {
641​ return new ResultsStream(QStringLiteral("FwupdStream"), {});
642​ } else
643​ return new ResultsStream(QStringLiteral("FwupdStream"), { res });
644​}
645​
646​AbstractBackendUpdater* FwupdBackend::backendUpdater() const
647​{
648​ return m_updater;
649​}
650​
651​AbstractReviewsBackend* FwupdBackend::reviewsBackend() const
652​{
653​ return nullptr;
654​}
655​
656​Transaction* FwupdBackend::installApplication(AbstractResource* app, const AddonList& addons)
657​{
658​ return new FwupdTransaction(qobject_cast<FwupdResource*>(app), this, addons, Transaction::InstallRole);
apolUnsubmitted
Done

Use nullptr everywhere you use NULL.

apol: Use nullptr everywhere you use NULL.
659​}
660​
661​Transaction* FwupdBackend::installApplication(AbstractResource* app)
662​{
663​ return new FwupdTransaction(qobject_cast<FwupdResource*>(app), this, Transaction::InstallRole);
664​}
665​
666​Transaction* FwupdBackend::removeApplication(AbstractResource* app)
667​{
668​ return new FwupdTransaction(qobject_cast<FwupdResource*>(app), this, Transaction::RemoveRole);
669​}
670​
671​void FwupdBackend::checkForUpdates()
672​{
673​ if(m_fetching)
674​ return;
675​
676​ populate(QStringLiteral("Releases"));
677​ toggleFetching();
678​ QTimer::singleShot(500, this, &FwupdBackend::toggleFetching);
679​}
680​
681​AbstractResource * FwupdBackend::resourceForFile(const QUrl& path)
682​{
683​ g_autoptr(GError) error = nullptr;
684​
685​ QMimeDatabase db;
686​ QMimeType type = db.mimeTypeForFile(path.fileName());
687​ FwupdResource* app = nullptr;
688​
689​ if(type.isValid() && type.inherits(QStringLiteral("application/vnd.ms-cab-compressed")))
690​ {
691​ g_autofree gchar *filename = path.fileName().toUtf8().data();
692​ g_autoptr(GPtrArray) devices = fwupd_client_get_details(client, filename, nullptr, &error);
693​
694​ if (devices)
695​ {
696​ FwupdDevice *dev = (FwupdDevice *)g_ptr_array_index(devices, 0);
697​ app = createRelease(dev);
698​ app->setState(AbstractResource::None);
699​ for (uint i = 1; i < devices->len; i++)
700​ {
701​ FwupdDevice *dev = (FwupdDevice *)g_ptr_array_index(devices, i);
702​ FwupdResource* app_ = createRelease(dev);
703​ app_->setState(AbstractResource::None);
704​ if(!app->m_releases.contains(app_))
705​ app->m_releases.append(app_);
706​ }
707​ m_resources.insert(app->packageName(), app);
708​ addResourceToList(app);
709​ connect(app, &FwupdResource::stateChanged, this, &FwupdBackend::updatesCountChanged);
710​ }
711​ else
712​ {
713​ handleError(&error);
714​ }
715​ }
716​ return app;
717​}
718​
719​QString FwupdBackend::displayName() const
720​{
721​ return QStringLiteral("Firmware Updates");
722​}
723​
724​bool FwupdBackend::hasApplications() const
725​{
726​ return !m_resources.isEmpty() ? true : false;
727​}
728​
729​#include "FwupdBackend.moc"
apolUnsubmitted
Done

return !m_resources.isEmpty()

apol: return !m_resources.isEmpty()