1 /**************************************************************************
2 * Otter Browser: Web browser controlled by the user, not vice-versa.
3 * Copyright (C) 2013 - 2019 Michal Dutkiewicz aka Emdek <michal@emdek.pl>
4 * Copyright (C) 2014 Piotr Wójcik <chocimier@tlen.pl>
5 *
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 *
19 **************************************************************************/
20
21 #include "NetworkManagerFactory.h"
22 #include "AddonsManager.h"
23 #include "ContentFiltersManager.h"
24 #include "CookieJar.h"
25 #include "NetworkCache.h"
26 #include "NetworkManager.h"
27 #include "NetworkProxyFactory.h"
28 #include "SessionsManager.h"
29 #include "SettingsManager.h"
30 #include "WebBackend.h"
31
32 #include <QtCore/QDir>
33 #include <QtCore/QFile>
34 #include <QtCore/QJsonArray>
35 #include <QtCore/QJsonDocument>
36 #include <QtCore/QJsonObject>
37 #include <QtNetwork/QNetworkConfigurationManager>
38 #include <QtNetwork/QSslConfiguration>
39
40 namespace Otter
41 {
42
43 NetworkManagerFactory* NetworkManagerFactory::m_instance(nullptr);
44 NetworkManager* NetworkManagerFactory::m_privateNetworkManager(nullptr);
45 NetworkManager* NetworkManagerFactory::m_standardNetworkManager(nullptr);
46 NetworkProxyFactory* NetworkManagerFactory::m_proxyFactory(nullptr);
47 NetworkCache* NetworkManagerFactory::m_cache(nullptr);
48 CookieJar* NetworkManagerFactory::m_cookieJar(nullptr);
49 QString NetworkManagerFactory::m_acceptLanguage;
50 QMap<QString, ProxyDefinition> NetworkManagerFactory::m_proxies;
51 QMap<QString, UserAgentDefinition> NetworkManagerFactory::m_userAgents;
52 NetworkManagerFactory::DoNotTrackPolicy NetworkManagerFactory::m_doNotTrackPolicy(NetworkManagerFactory::SkipTrackPolicy);
53 QList<QSslCipher> NetworkManagerFactory::m_defaultCiphers;
54 bool NetworkManagerFactory::m_canSendReferrer(true);
55 bool NetworkManagerFactory::m_isInitialized(false);
56 bool NetworkManagerFactory::m_isWorkingOffline(false);
57
ProxiesModel(const QString & selectedProxy,bool isEditor,QObject * parent)58 ProxiesModel::ProxiesModel(const QString &selectedProxy, bool isEditor, QObject *parent) : ItemModel(parent),
59 m_isEditor(isEditor)
60 {
61 if (isEditor)
62 {
63 setExclusive(true);
64 }
65
66 populateProxies(NetworkManagerFactory::getProxies(), invisibleRootItem(), selectedProxy);
67 }
68
populateProxies(const QStringList & proxies,QStandardItem * parent,const QString & selectedProxy)69 void ProxiesModel::populateProxies(const QStringList &proxies, QStandardItem *parent, const QString &selectedProxy)
70 {
71 for (int i = 0; i < proxies.count(); ++i)
72 {
73 const ProxyDefinition proxy(proxies.at(i).isEmpty() ? ProxyDefinition() : NetworkManagerFactory::getProxy(proxies.at(i)));
74 ItemType type(EntryType);
75 QStandardItem *item(new QStandardItem(proxy.isValid() ? proxy.getTitle() : QString()));
76 item->setData(item->data(Qt::DisplayRole), Qt::ToolTipRole);
77
78 if (m_isEditor)
79 {
80 item->setFlags(item->flags() | Qt::ItemIsDragEnabled);
81 }
82
83 if (proxy.isFolder)
84 {
85 item->setData(proxies.at(i), IdentifierRole);
86
87 type = FolderType;
88
89 if (!m_isEditor)
90 {
91 item->setFlags(item->flags() & ~Qt::ItemIsSelectable);
92 }
93
94 populateProxies(proxy.children, item, selectedProxy);
95 }
96 else
97 {
98 if (proxies.at(i).isEmpty())
99 {
100 type = SeparatorType;
101
102 if (!m_isEditor)
103 {
104 item->setFlags(item->flags() & ~Qt::ItemIsSelectable);
105 }
106 }
107 else
108 {
109 item->setData(proxies.at(i), IdentifierRole);
110
111 if (m_isEditor)
112 {
113 item->setCheckable(true);
114
115 if (proxy.identifier == selectedProxy)
116 {
117 item->setData(Qt::Checked, Qt::CheckStateRole);
118 }
119 }
120 }
121
122 item->setFlags(item->flags() | Qt::ItemNeverHasChildren);
123 }
124
125 insertRow(item, parent, -1, type);
126 }
127 }
128
UserAgentsModel(const QString & selectedUserAgent,bool isEditor,QObject * parent)129 UserAgentsModel::UserAgentsModel(const QString &selectedUserAgent, bool isEditor, QObject *parent) : ItemModel(parent),
130 m_isEditor(isEditor)
131 {
132 if (isEditor)
133 {
134 setExclusive(true);
135 }
136
137 populateUserAgents(NetworkManagerFactory::getUserAgents(), invisibleRootItem(), selectedUserAgent);
138 }
139
populateUserAgents(const QStringList & userAgents,QStandardItem * parent,const QString & selectedUserAgent)140 void UserAgentsModel::populateUserAgents(const QStringList &userAgents, QStandardItem *parent, const QString &selectedUserAgent)
141 {
142 for (int i = 0; i < userAgents.count(); ++i)
143 {
144 const UserAgentDefinition userAgent(userAgents.at(i).isEmpty() ? UserAgentDefinition() : NetworkManagerFactory::getUserAgent(userAgents.at(i)));
145 ItemType type(EntryType);
146 QList<QStandardItem*> items({new QStandardItem(userAgent.isValid() ? userAgent.getTitle() : QString())});
147 items[0]->setData(items[0]->data(Qt::DisplayRole), Qt::ToolTipRole);
148
149 if (m_isEditor)
150 {
151 items.append(new QStandardItem(userAgent.value));
152 items[0]->setFlags(items[0]->flags() | Qt::ItemIsDragEnabled);
153 items[1]->setData(items[1]->data(Qt::DisplayRole), Qt::ToolTipRole);
154 items[1]->setFlags(items[1]->flags() | Qt::ItemIsDragEnabled);
155 }
156
157 if (userAgent.isFolder)
158 {
159 type = FolderType;
160
161 if (!m_isEditor)
162 {
163 items[0]->setFlags(items[0]->flags() & ~Qt::ItemIsSelectable);
164 }
165
166 populateUserAgents(userAgent.children, items[0], selectedUserAgent);
167 }
168 else
169 {
170 if (userAgents.at(i).isEmpty())
171 {
172 type = SeparatorType;
173
174 if (!m_isEditor)
175 {
176 items[0]->setFlags(items[0]->flags() & ~Qt::ItemIsSelectable);
177 }
178 }
179 else
180 {
181 items[0]->setData(userAgents.at(i), IdentifierRole);
182 items[0]->setData(userAgent.value, UserAgentRole);
183
184 if (m_isEditor)
185 {
186 items[0]->setCheckable(true);
187
188 if (userAgent.identifier == selectedUserAgent)
189 {
190 items[0]->setData(Qt::Checked, Qt::CheckStateRole);
191 }
192 }
193 }
194
195 items[0]->setFlags(items[0]->flags() | Qt::ItemNeverHasChildren);
196
197 if (m_isEditor)
198 {
199 items[1]->setFlags(items[1]->flags() | Qt::ItemNeverHasChildren);
200 }
201 }
202
203 insertRow(items, parent, -1, type);
204 }
205 }
206
NetworkManagerFactory(QObject * parent)207 NetworkManagerFactory::NetworkManagerFactory(QObject *parent) : QObject(parent)
208 {
209 QNetworkConfigurationManager *networkConfigurationManager(new QNetworkConfigurationManager(this));
210 const QStringList paths({QDir(QCoreApplication::applicationDirPath()).filePath(QLatin1String("certificates")), SessionsManager::getWritableDataPath(QLatin1String("certificates"))});
211
212 for (int i = 0; i < paths.count(); ++i)
213 {
214 if (QFile::exists(paths.at(i)))
215 {
216 QSslSocket::addDefaultCaCertificates(QDir(paths.at(i)).filePath(QLatin1String("*")), QSsl::Pem, QRegExp::Wildcard);
217 }
218
219 }
220
221 connect(networkConfigurationManager, &QNetworkConfigurationManager::onlineStateChanged, this, &NetworkManagerFactory::onlineStateChanged);
222 }
223
createInstance()224 void NetworkManagerFactory::createInstance()
225 {
226 if (!m_instance)
227 {
228 m_proxyFactory = new NetworkProxyFactory();
229 m_instance = new NetworkManagerFactory(QCoreApplication::instance());
230
231 QNetworkProxyFactory::setApplicationProxyFactory(m_proxyFactory);
232
233 ContentFiltersManager::createInstance();
234 }
235 }
236
initialize()237 void NetworkManagerFactory::initialize()
238 {
239 if (m_isInitialized)
240 {
241 return;
242 }
243
244 m_isInitialized = true;
245 m_defaultCiphers = QSslConfiguration::defaultConfiguration().ciphers();
246
247 for (int i = (m_defaultCiphers.count() - 1); i >= 0; --i)
248 {
249 if (m_defaultCiphers.at(i).isNull() || (m_defaultCiphers.at(i).keyExchangeMethod() == QLatin1String("DH") && m_defaultCiphers.at(i).supportedBits() < 1024) || m_defaultCiphers.at(i).supportedBits() < 128 || m_defaultCiphers.at(i).authenticationMethod() == QLatin1String("PSK") || m_defaultCiphers.at(i).authenticationMethod() == QLatin1String("EXP") || m_defaultCiphers.at(i).authenticationMethod() == QLatin1String("nullptr") || m_defaultCiphers.at(i).encryptionMethod().startsWith(QLatin1String("RC4(")) || m_defaultCiphers.at(i).authenticationMethod() == QLatin1String("ADH"))
250 {
251 m_defaultCiphers.removeAt(i);
252 }
253 }
254
255 loadProxies();
256 loadUserAgents();
257
258 m_instance->handleOptionChanged(SettingsManager::Network_AcceptLanguageOption, SettingsManager::getOption(SettingsManager::Network_AcceptLanguageOption));
259 m_instance->handleOptionChanged(SettingsManager::Network_DoNotTrackPolicyOption, SettingsManager::getOption(SettingsManager::Network_DoNotTrackPolicyOption));
260 m_instance->handleOptionChanged(SettingsManager::Network_EnableReferrerOption, SettingsManager::getOption(SettingsManager::Network_EnableReferrerOption));
261 m_instance->handleOptionChanged(SettingsManager::Network_ProxyOption, SettingsManager::getOption(SettingsManager::Network_ProxyOption));
262 m_instance->handleOptionChanged(SettingsManager::Network_WorkOfflineOption, SettingsManager::getOption(SettingsManager::Network_WorkOfflineOption));
263 m_instance->handleOptionChanged(SettingsManager::Security_CiphersOption, SettingsManager::getOption(SettingsManager::Security_CiphersOption));
264
265 connect(SettingsManager::getInstance(), &SettingsManager::optionChanged, m_instance, &NetworkManagerFactory::handleOptionChanged);
266 }
267
clearCookies(int period)268 void NetworkManagerFactory::clearCookies(int period)
269 {
270 if (!m_cookieJar)
271 {
272 m_cookieJar = new CookieJar(QCoreApplication::instance());
273 }
274
275 m_cookieJar->clearCookies(period);
276 }
277
clearCache(int period)278 void NetworkManagerFactory::clearCache(int period)
279 {
280 if (m_cache)
281 {
282 m_cache->clearCache(period);
283 }
284 }
285
loadProxies()286 void NetworkManagerFactory::loadProxies()
287 {
288 m_proxies.clear();
289
290 QFile file(SessionsManager::getReadableDataPath(QLatin1String("proxies.json")));
291
292 if (!file.open(QIODevice::ReadOnly))
293 {
294 m_proxyFactory->setProxy(SettingsManager::getOption(SettingsManager::Network_ProxyOption).toString());
295
296 return;
297 }
298
299 const QJsonArray proxies(QJsonDocument::fromJson(file.readAll()).array());
300 ProxyDefinition root;
301
302 for (int i = 0; i < proxies.count(); ++i)
303 {
304 readProxy(proxies.at(i), &root);
305 }
306
307 file.close();
308
309 m_proxies[QLatin1String("root")] = root;
310
311 updateProxiesOption();
312
313 m_proxyFactory->setProxy(SettingsManager::getOption(SettingsManager::Network_ProxyOption).toString());
314 }
315
loadUserAgents()316 void NetworkManagerFactory::loadUserAgents()
317 {
318 m_userAgents.clear();
319
320 QFile file(SessionsManager::getReadableDataPath(QLatin1String("userAgents.json")));
321
322 if (!file.open(QIODevice::ReadOnly))
323 {
324 return;
325 }
326
327 const QJsonArray userAgents(QJsonDocument::fromJson(file.readAll()).array());
328 UserAgentDefinition root;
329
330 for (int i = 0; i < userAgents.count(); ++i)
331 {
332 readUserAgent(userAgents.at(i), &root);
333 }
334
335 file.close();
336
337 m_userAgents[QLatin1String("root")] = root;
338
339 updateUserAgentsOption();
340 }
341
readProxy(const QJsonValue & value,ProxyDefinition * parent)342 void NetworkManagerFactory::readProxy(const QJsonValue &value, ProxyDefinition *parent)
343 {
344 if (!value.isObject())
345 {
346 if (value.isString() && value.toString() == QLatin1String("separator"))
347 {
348 parent->children.append(QString());
349 }
350
351 return;
352 }
353
354 const QJsonObject proxyObject(value.toObject());
355 const QString identifier(proxyObject.value(QLatin1String("identifier")).toString());
356
357 if (!m_proxies.contains(identifier))
358 {
359 ProxyDefinition proxy;
360 proxy.identifier = identifier;
361 proxy.title = proxyObject.value(QLatin1String("title")).toString();
362
363 if (proxyObject.contains(QLatin1String("children")))
364 {
365 proxy.isFolder = true;
366
367 const QJsonArray childrenArray(proxyObject.value(QLatin1String("children")).toArray());
368
369 for (int i = 0; i < childrenArray.count(); ++i)
370 {
371 readProxy(childrenArray.at(i), &proxy);
372 }
373 }
374 else
375 {
376 const QString type(proxyObject.value(QLatin1String("type")).toString());
377
378 if (type == QLatin1String("noProxy"))
379 {
380 proxy.type = ProxyDefinition::NoProxy;
381 }
382 else if (type == QLatin1String("manualProxy"))
383 {
384 proxy.type = ProxyDefinition::ManualProxy;
385 }
386 else if (type == QLatin1String("automaticProxy"))
387 {
388 proxy.type = ProxyDefinition::AutomaticProxy;
389 }
390 else
391 {
392 proxy.type = ProxyDefinition::SystemProxy;
393 }
394
395 if (proxy.type == ProxyDefinition::ManualProxy && proxyObject.contains(QLatin1String("servers")))
396 {
397 const QJsonArray serversArray(proxyObject.value(QLatin1String("servers")).toArray());
398
399 for (int i = 0; i < serversArray.count(); ++i)
400 {
401 const QJsonObject serverObject(serversArray.at(i).toObject());
402 const QString protocol(serverObject.value(QLatin1String("protocol")).toString());
403 ProxyDefinition::ProxyServer server;
404 server.hostName = serverObject.value(QLatin1String("hostName")).toString();
405 server.port = static_cast<quint16>(serverObject.value(QLatin1String("port")).toInt());
406
407 if (protocol == QLatin1String("http"))
408 {
409 proxy.servers[ProxyDefinition::HttpProtocol] = server;
410 }
411 else if (protocol == QLatin1String("https"))
412 {
413 proxy.servers[ProxyDefinition::HttpsProtocol] = server;
414 }
415 else if (protocol == QLatin1String("ftp"))
416 {
417 proxy.servers[ProxyDefinition::FtpProtocol] = server;
418 }
419 else if (protocol == QLatin1String("socks"))
420 {
421 proxy.servers[ProxyDefinition::SocksProtocol] = server;
422 }
423 else
424 {
425 proxy.servers[ProxyDefinition::AnyProtocol] = server;
426 }
427 }
428 }
429
430 proxy.path = proxyObject.value(QLatin1String("path")).toString();
431 proxy.exceptions = proxyObject.value(QLatin1String("exceptions")).toVariant().toStringList();
432 proxy.usesSystemAuthentication = proxyObject.value(QLatin1String("usesSystemAuthentication")).toBool(false);
433 }
434
435 m_proxies[identifier] = proxy;
436 }
437
438 parent->children.append(identifier);
439 }
440
readUserAgent(const QJsonValue & value,UserAgentDefinition * parent)441 void NetworkManagerFactory::readUserAgent(const QJsonValue &value, UserAgentDefinition *parent)
442 {
443 if (!value.isObject())
444 {
445 if (value.isString() && value.toString() == QLatin1String("separator"))
446 {
447 parent->children.append(QString());
448 }
449
450 return;
451 }
452
453 const QJsonObject userAgentObject(value.toObject());
454 const QString identifier(userAgentObject.value(QLatin1String("identifier")).toString());
455
456 if (!m_userAgents.contains(identifier))
457 {
458 UserAgentDefinition userAgent;
459 userAgent.identifier = identifier;
460 userAgent.name = userAgentObject.value(QLatin1String("name")).toString();
461 userAgent.title = userAgentObject.value(QLatin1String("title")).toString();
462
463 if (identifier == QLatin1String("default"))
464 {
465 userAgent.value = QLatin1String("Mozilla/5.0 {platform} {engineVersion} {applicationVersion}");
466 }
467 else if (userAgentObject.contains(QLatin1String("children")))
468 {
469 userAgent.isFolder = true;
470
471 const QJsonArray childrenArray(userAgentObject.value(QLatin1String("children")).toArray());
472
473 for (int i = 0; i < childrenArray.count(); ++i)
474 {
475 readUserAgent(childrenArray.at(i), &userAgent);
476 }
477 }
478 else
479 {
480 userAgent.value = userAgentObject.value(QLatin1String("value")).toString();
481 }
482
483 m_userAgents[identifier] = userAgent;
484 }
485
486 parent->children.append(identifier);
487 }
488
handleOptionChanged(int identifier,const QVariant & value)489 void NetworkManagerFactory::handleOptionChanged(int identifier, const QVariant &value)
490 {
491 switch (identifier)
492 {
493 case SettingsManager::Network_AcceptLanguageOption:
494 m_acceptLanguage = ((value.toString().isEmpty()) ? QLatin1String(" ") : value.toString().replace(QLatin1String("system"), QLocale::system().bcp47Name()));
495
496 break;
497 case SettingsManager::Network_DoNotTrackPolicyOption:
498 {
499 const QString policyValue(value.toString());
500
501 if (policyValue == QLatin1String("allow"))
502 {
503 m_doNotTrackPolicy = AllowToTrackPolicy;
504 }
505 else if (policyValue == QLatin1String("doNotAllow"))
506 {
507 m_doNotTrackPolicy = DoNotAllowToTrackPolicy;
508 }
509 else
510 {
511 m_doNotTrackPolicy = SkipTrackPolicy;
512 }
513 }
514
515 break;
516 case SettingsManager::Network_EnableReferrerOption:
517 m_canSendReferrer = value.toBool();
518
519 break;
520 case SettingsManager::Network_ProxyOption:
521 m_proxyFactory->setProxy(value.toString());
522
523 break;
524 case SettingsManager::Network_WorkOfflineOption:
525 m_isWorkingOffline = value.toBool();
526
527 break;
528 case SettingsManager::Security_CiphersOption:
529 {
530 QSslConfiguration configuration(QSslConfiguration::defaultConfiguration());
531
532 if (value.toString() == QLatin1String("default"))
533 {
534 configuration.setCiphers(m_defaultCiphers);
535 }
536 else
537 {
538 const QStringList selectedCiphers(value.toStringList());
539 QList<QSslCipher> ciphers;
540
541 for (int i = 0; i < selectedCiphers.count(); ++i)
542 {
543 const QSslCipher cipher(selectedCiphers.at(i));
544
545 if (!cipher.isNull())
546 {
547 ciphers.append(cipher);
548 }
549 }
550
551 configuration.setCiphers(ciphers);
552 }
553
554 QSslConfiguration::setDefaultConfiguration(configuration);
555 }
556
557 break;
558 default:
559 break;
560 }
561 }
562
notifyAuthenticated(QAuthenticator * authenticator,bool wasAccepted)563 void NetworkManagerFactory::notifyAuthenticated(QAuthenticator *authenticator, bool wasAccepted)
564 {
565 emit m_instance->authenticated(authenticator, wasAccepted);
566 }
567
updateProxiesOption()568 void NetworkManagerFactory::updateProxiesOption()
569 {
570 SettingsManager::OptionDefinition proxiesOption(SettingsManager::getOptionDefinition(SettingsManager::Network_ProxyOption));
571 proxiesOption.choices.clear();
572 proxiesOption.choices.reserve(qRound(m_proxies.count() * 0.75));
573
574 QMap<QString, ProxyDefinition>::iterator iterator;
575
576 for (iterator = m_proxies.begin(); iterator != m_proxies.end(); ++iterator)
577 {
578 if (!iterator.value().isFolder && !iterator.value().identifier.isEmpty())
579 {
580 proxiesOption.choices.append({iterator.value().getTitle(), iterator.value().identifier, {}});
581 }
582 }
583
584 SettingsManager::updateOptionDefinition(SettingsManager::Network_ProxyOption, proxiesOption);
585 }
586
updateUserAgentsOption()587 void NetworkManagerFactory::updateUserAgentsOption()
588 {
589 SettingsManager::OptionDefinition userAgentsOption(SettingsManager::getOptionDefinition(SettingsManager::Network_UserAgentOption));
590 userAgentsOption.choices.clear();
591 userAgentsOption.choices.reserve(qRound(m_userAgents.count() * 0.75));
592 userAgentsOption.choices.append({QCoreApplication::translate("userAgents", "Default User Agent"), QLatin1String("default"), {}});
593
594 QMap<QString, UserAgentDefinition>::iterator iterator;
595
596 for (iterator = m_userAgents.begin(); iterator != m_userAgents.end(); ++iterator)
597 {
598 if (!iterator.value().isFolder && !iterator.value().identifier.isEmpty() && iterator.value().identifier != QLatin1String("default"))
599 {
600 userAgentsOption.choices.append({iterator.value().getTitle(), iterator.value().identifier, {}});
601 }
602 }
603
604 SettingsManager::updateOptionDefinition(SettingsManager::Network_UserAgentOption, userAgentsOption);
605 }
606
getInstance()607 NetworkManagerFactory* NetworkManagerFactory::getInstance()
608 {
609 return m_instance;
610 }
611
getNetworkManager(bool isPrivate)612 NetworkManager* NetworkManagerFactory::getNetworkManager(bool isPrivate)
613 {
614 if (isPrivate && !m_privateNetworkManager)
615 {
616 m_privateNetworkManager = new NetworkManager(true, QCoreApplication::instance());
617 }
618 else if (!isPrivate && !m_standardNetworkManager)
619 {
620 m_standardNetworkManager = new NetworkManager(false, QCoreApplication::instance());
621 }
622
623 return (isPrivate ? m_privateNetworkManager : m_standardNetworkManager);
624 }
625
getCache()626 NetworkCache* NetworkManagerFactory::getCache()
627 {
628 if (!m_cache)
629 {
630 m_cache = new NetworkCache(QCoreApplication::instance());
631 }
632
633 return m_cache;
634 }
635
getCookieJar()636 CookieJar* NetworkManagerFactory::getCookieJar()
637 {
638 if (!m_cookieJar)
639 {
640 m_cookieJar = new CookieJar(false, QCoreApplication::instance());
641 }
642
643 return m_cookieJar;
644 }
645
createRequest(const QUrl & url,QNetworkAccessManager::Operation operation,bool isPrivate,QIODevice * outgoingData)646 QNetworkReply* NetworkManagerFactory::createRequest(const QUrl &url, QNetworkAccessManager::Operation operation, bool isPrivate, QIODevice *outgoingData)
647 {
648 QNetworkRequest request(url);
649 request.setAttribute(QNetworkRequest::FollowRedirectsAttribute, true);
650 request.setHeader(QNetworkRequest::UserAgentHeader, getUserAgent());
651
652 return getNetworkManager(isPrivate)->createRequest(operation, request, outgoingData);
653 }
654
getAcceptLanguage()655 QString NetworkManagerFactory::getAcceptLanguage()
656 {
657 return m_acceptLanguage;
658 }
659
getUserAgent()660 QString NetworkManagerFactory::getUserAgent()
661 {
662 return AddonsManager::getWebBackend()->getUserAgent();
663 }
664
getProxies()665 QStringList NetworkManagerFactory::getProxies()
666 {
667 if (!m_isInitialized)
668 {
669 m_instance->initialize();
670 }
671
672 return m_proxies[QLatin1String("root")].children;
673 }
674
getUserAgents()675 QStringList NetworkManagerFactory::getUserAgents()
676 {
677 if (!m_isInitialized)
678 {
679 m_instance->initialize();
680 }
681
682 return m_userAgents[QLatin1String("root")].children;
683 }
684
getDefaultCiphers()685 QList<QSslCipher> NetworkManagerFactory::getDefaultCiphers()
686 {
687 return m_defaultCiphers;
688 }
689
getProxy(const QString & identifier)690 ProxyDefinition NetworkManagerFactory::getProxy(const QString &identifier)
691 {
692 if (!m_isInitialized)
693 {
694 m_instance->initialize();
695 }
696
697 if (identifier.isEmpty() || !m_proxies.contains(identifier))
698 {
699 ProxyDefinition proxy;
700 proxy.identifier = QLatin1String("systemProxy");
701 proxy.title = QT_TRANSLATE_NOOP("proxies", "System Configuration");
702 proxy.type = ProxyDefinition::SystemProxy;
703
704 return proxy;
705 }
706
707 return m_proxies[identifier];
708 }
709
getUserAgent(const QString & identifier)710 UserAgentDefinition NetworkManagerFactory::getUserAgent(const QString &identifier)
711 {
712 if (identifier.startsWith(QLatin1String("custom;")))
713 {
714 UserAgentDefinition userAgent;
715 userAgent.identifier = QLatin1String("custom");
716 userAgent.title = tr("Custom");
717 userAgent.value = identifier.mid(7);
718
719 return userAgent;
720 }
721
722 if (!m_isInitialized)
723 {
724 m_instance->initialize();
725 }
726
727 if (identifier.isEmpty() || !m_userAgents.contains(identifier))
728 {
729 UserAgentDefinition userAgent;
730 userAgent.identifier = QLatin1String("default");
731 userAgent.title = QT_TRANSLATE_NOOP("userAgents", "Default User Agent");
732 userAgent.value = QLatin1String("Mozilla/5.0 {platform} {engineVersion} {applicationVersion}");
733
734 return userAgent;
735 }
736
737 return m_userAgents[identifier];
738 }
739
getDoNotTrackPolicy()740 NetworkManagerFactory::DoNotTrackPolicy NetworkManagerFactory::getDoNotTrackPolicy()
741 {
742 return m_doNotTrackPolicy;
743 }
744
canSendReferrer()745 bool NetworkManagerFactory::canSendReferrer()
746 {
747 return m_canSendReferrer;
748 }
749
isWorkingOffline()750 bool NetworkManagerFactory::isWorkingOffline()
751 {
752 return m_isWorkingOffline;
753 }
754
usesSystemProxyAuthentication()755 bool NetworkManagerFactory::usesSystemProxyAuthentication()
756 {
757 return m_proxyFactory->usesSystemAuthentication();
758 }
759
event(QEvent * event)760 bool NetworkManagerFactory::event(QEvent *event)
761 {
762 if (event->type() == QEvent::LanguageChange)
763 {
764 if (!m_proxies.isEmpty())
765 {
766 updateProxiesOption();
767 }
768
769 if (!m_userAgents.isEmpty())
770 {
771 updateUserAgentsOption();
772 }
773 }
774
775 return QObject::event(event);
776 }
777
778 }
779