• Skip to content
  • Skip to link menu
  • KDE API Reference
  • kdelibs-4.14.38 API Reference
  • KDE Home
  • Contact Us
 

KIO

  • kio
  • kio
accessmanager.cpp
Go to the documentation of this file.
1/*
2 * This file is part of the KDE project.
3 *
4 * Copyright (C) 2009 - 2012 Dawit Alemayehu <adawit @ kde.org>
5 * Copyright (C) 2008 - 2009 Urs Wolfer <uwolfer @ kde.org>
6 * Copyright (C) 2007 Trolltech ASA
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Library General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
12 *
13 * This library 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 GNU
16 * Library General Public License for more details.
17 *
18 * You should have received a copy of the GNU Library General Public License
19 * along with this library; see the file COPYING.LIB. If not, write to
20 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 * Boston, MA 02110-1301, USA.
22 *
23 */
24
25#include "accessmanager.h"
26
27#include "accessmanagerreply_p.h"
28#include "job.h"
29#include "scheduler.h"
30#include "jobuidelegate.h"
31#include "netaccess.h"
32
33#include <kdebug.h>
34#include <kconfiggroup.h>
35#include <ksharedconfig.h>
36#include <kprotocolinfo.h>
37#include <klocalizedstring.h>
38
39#include <QtCore/QUrl>
40#include <QtCore/QPointer>
41#include <QtGui/QWidget>
42#include <QtDBus/QDBusInterface>
43#include <QtDBus/QDBusConnection>
44#include <QtDBus/QDBusReply>
45#include <QtNetwork/QNetworkReply>
46#include <QtNetwork/QNetworkRequest>
47#include <QtNetwork/QSslCipher>
48#include <QtNetwork/QSslCertificate>
49#include <QtNetwork/QSslConfiguration>
50
51#define QL1S(x) QLatin1String(x)
52#define QL1C(x) QLatin1Char(x)
53
54#if QT_VERSION >= 0x040800
55static QNetworkRequest::Attribute gSynchronousNetworkRequestAttribute = QNetworkRequest::SynchronousRequestAttribute;
56#else // QtWebkit hack to use the internal attribute
57static QNetworkRequest::Attribute gSynchronousNetworkRequestAttribute = static_cast<QNetworkRequest::Attribute>(QNetworkRequest::HttpPipeliningWasUsedAttribute + 7);
58#endif
59
60
61
62
63static qint64 sizeFromRequest(const QNetworkRequest& req)
64{
65 const QVariant size = req.header(QNetworkRequest::ContentLengthHeader);
66 if (!size.isValid())
67 return -1;
68 bool ok = false;
69 const qlonglong value = size.toLongLong(&ok);
70 return (ok ? value : -1);
71}
72
73namespace KIO {
74
75class AccessManager::AccessManagerPrivate
76{
77public:
78 AccessManagerPrivate()
79 : externalContentAllowed(true),
80 emitReadyReadOnMetaDataChange(false),
81 window(0)
82 {}
83
84 void setMetaDataForRequest(QNetworkRequest request, KIO::MetaData& metaData);
85
86 bool externalContentAllowed;
87 bool emitReadyReadOnMetaDataChange;
88 KIO::MetaData requestMetaData;
89 KIO::MetaData sessionMetaData;
90 QPointer<QWidget> window;
91};
92
93namespace Integration {
94
95class CookieJar::CookieJarPrivate
96{
97public:
98 CookieJarPrivate()
99 : windowId((WId)-1),
100 isEnabled(true),
101 isStorageDisabled(false)
102 {}
103
104 WId windowId;
105 bool isEnabled;
106 bool isStorageDisabled;
107};
108
109}
110
111}
112
113using namespace KIO;
114
115AccessManager::AccessManager(QObject *parent)
116 :QNetworkAccessManager(parent), d(new AccessManager::AccessManagerPrivate())
117{
118 // KDE Cookiejar (KCookieJar) integration...
119 setCookieJar(new KIO::Integration::CookieJar);
120}
121
122AccessManager::~AccessManager()
123{
124 delete d;
125}
126
127void AccessManager::setExternalContentAllowed(bool allowed)
128{
129 d->externalContentAllowed = allowed;
130}
131
132bool AccessManager::isExternalContentAllowed() const
133{
134 return d->externalContentAllowed;
135}
136
137#ifndef KDE_NO_DEPRECATED
138void AccessManager::setCookieJarWindowId(WId id)
139{
140 QWidget* window = QWidget::find(id);
141 if (!window) {
142 return;
143 }
144
145 KIO::Integration::CookieJar *jar = qobject_cast<KIO::Integration::CookieJar *> (cookieJar());
146 if (jar) {
147 jar->setWindowId(id);
148 }
149
150 d->window = window->isWindow() ? window : window->window();
151}
152#endif
153
154void AccessManager::setWindow(QWidget* widget)
155{
156 if (!widget) {
157 return;
158 }
159
160 d->window = widget->isWindow() ? widget : widget->window();
161
162 if (!d->window) {
163 return;
164 }
165
166 KIO::Integration::CookieJar *jar = qobject_cast<KIO::Integration::CookieJar *> (cookieJar());
167 if (jar) {
168 jar->setWindowId(d->window->winId());
169 }
170}
171
172#ifndef KDE_NO_DEPRECATED
173WId AccessManager::cookieJarWindowid() const
174{
175 KIO::Integration::CookieJar *jar = qobject_cast<KIO::Integration::CookieJar *> (cookieJar());
176 if (jar)
177 return jar->windowId();
178
179 return 0;
180}
181#endif
182
183QWidget* AccessManager::window() const
184{
185 return d->window;
186}
187
188KIO::MetaData& AccessManager::requestMetaData()
189{
190 return d->requestMetaData;
191}
192
193KIO::MetaData& AccessManager::sessionMetaData()
194{
195 return d->sessionMetaData;
196}
197
198void AccessManager::putReplyOnHold(QNetworkReply* reply)
199{
200 KDEPrivate::AccessManagerReply* r = qobject_cast<KDEPrivate::AccessManagerReply*>(reply);
201 if (!r) {
202 return;
203 }
204
205 r->putOnHold();
206}
207
208void AccessManager::setEmitReadyReadOnMetaDataChange(bool enable)
209{
210 d->emitReadyReadOnMetaDataChange = enable;
211}
212
213QNetworkReply *AccessManager::createRequest(Operation op, const QNetworkRequest &req, QIODevice *outgoingData)
214{
215 const KUrl reqUrl (req.url());
216
217 if (!d->externalContentAllowed &&
218 !KDEPrivate::AccessManagerReply::isLocalRequest(reqUrl) &&
219 reqUrl.scheme() != QL1S("data")) {
220 kDebug( 7044 ) << "Blocked: " << reqUrl;
221 return new KDEPrivate::AccessManagerReply(op, req, QNetworkReply::ContentAccessDenied, i18n("Blocked request."), this);
222 }
223
224 // Check if the internal ignore content disposition header is set.
225 const bool ignoreContentDisposition = req.hasRawHeader("x-kdewebkit-ignore-disposition");
226
227 // Retrieve the KIO meta data...
228 KIO::MetaData metaData;
229 d->setMetaDataForRequest(req, metaData);
230
231 KIO::SimpleJob *kioJob = 0;
232
233 switch (op) {
234 case HeadOperation: {
235 //kDebug( 7044 ) << "HeadOperation:" << reqUrl;
236 kioJob = KIO::mimetype(reqUrl, KIO::HideProgressInfo);
237 break;
238 }
239 case GetOperation: {
240 //kDebug( 7044 ) << "GetOperation:" << reqUrl;
241 if (!reqUrl.path().isEmpty() || reqUrl.host().isEmpty())
242 kioJob = KIO::get(reqUrl, KIO::NoReload, KIO::HideProgressInfo);
243 else
244 kioJob = KIO::stat(reqUrl, KIO::HideProgressInfo);
245
246 // WORKAROUND: Avoid the brain damaged stuff QtWebKit does when a POST
247 // operation is redirected! See BR# 268694.
248 metaData.remove(QL1S("content-type")); // Remove the content-type from a GET/HEAD request!
249 break;
250 }
251 case PutOperation: {
252 //kDebug( 7044 ) << "PutOperation:" << reqUrl;
253 const qint64 size = sizeFromRequest(req);
254 if (size > 0) {
255 kioJob = KIO::http_post(reqUrl, outgoingData, size, KIO::HideProgressInfo);
256 metaData.insert(QL1S("CustomHTTPMethod"), QL1S("PUT"));
257 } else {
258 kioJob = KIO::put(reqUrl, -1, KIO::HideProgressInfo);
259 }
260 break;
261 }
262 case PostOperation: {
263 kioJob = KIO::http_post(reqUrl, outgoingData, sizeFromRequest(req), KIO::HideProgressInfo);
264 if (!metaData.contains(QL1S("content-type"))) {
265 const QVariant header = req.header(QNetworkRequest::ContentTypeHeader);
266 if (header.isValid()) {
267 metaData.insert(QL1S("content-type"),
268 (QL1S("Content-Type: ") + header.toString()));
269 } else {
270 metaData.insert(QL1S("content-type"),
271 QL1S("Content-Type: application/x-www-form-urlencoded"));
272 }
273 }
274 break;
275 }
276 case DeleteOperation: {
277 //kDebug(7044) << "DeleteOperation:" << reqUrl;
278 const qint64 size = sizeFromRequest(req);
279 if (size > 0) {
280 kioJob = KIO::http_post(reqUrl, outgoingData, size, KIO::HideProgressInfo);
281 metaData.insert(QL1S("CustomHTTPMethod"), QL1S("DELETE"));
282 } else {
283 kioJob = KIO::http_delete(reqUrl, KIO::HideProgressInfo);
284 }
285 break;
286 }
287 case CustomOperation: {
288 const QByteArray& method = req.attribute(QNetworkRequest::CustomVerbAttribute).toByteArray();
289 //kDebug(7044) << "CustomOperation:" << reqUrl << "method:" << method << "outgoing data:" << outgoingData;
290
291 if (method.isEmpty()) {
292 return new KDEPrivate::AccessManagerReply(op, req, QNetworkReply::ProtocolUnknownError, i18n("Unknown HTTP verb."), this);
293 }
294
295 const qint64 size = sizeFromRequest(req);
296 if (size > 0)
297 kioJob = KIO::http_post(reqUrl, outgoingData, size, KIO::HideProgressInfo);
298 else
299 kioJob = KIO::get(reqUrl, KIO::NoReload, KIO::HideProgressInfo);
300
301 metaData.insert(QL1S("CustomHTTPMethod"), method);
302 break;
303 }
304 default: {
305 kWarning(7044) << "Unsupported KIO operation requested! Defering to QNetworkAccessManager...";
306 return QNetworkAccessManager::createRequest(op, req, outgoingData);
307 }
308 }
309
310 // Set the job priority
311 switch (req.priority()) {
312 case QNetworkRequest::HighPriority:
313 KIO::Scheduler::setJobPriority(kioJob, -5);
314 break;
315 case QNetworkRequest::LowPriority:
316 KIO::Scheduler::setJobPriority(kioJob, 5);
317 break;
318 default:
319 break;
320 }
321
322 KDEPrivate::AccessManagerReply *reply;
323
324 /*
325 NOTE: Here we attempt to handle synchronous XHR requests. Unfortunately,
326 due to the fact that QNAM is both synchronous and multi-thread while KIO
327 is completely the opposite (asynchronous and not thread safe), the code
328 below might cause crashes like the one reported in bug# 287778 (nested
329 event loops are inherently dangerous).
330
331 Unfortunately, all attempts to address the crash has so far failed due to
332 the many regressions they caused, e.g. bug# 231932 and 297954. Hence, until
333 a solution is found, we have to live with the side effects of creating
334 nested event loops.
335 */
336 if (req.attribute(gSynchronousNetworkRequestAttribute).toBool()) {
337 KUrl finalURL;
338 QByteArray data;
339
340 if (KIO::NetAccess::synchronousRun(kioJob, d->window, &data, &finalURL, &metaData)) {
341 reply = new KDEPrivate::AccessManagerReply(op, req, data, finalURL, metaData, this);
342 kDebug(7044) << "Synchronous XHR:" << reply << reqUrl;
343 } else {
344 kWarning(7044) << "Failed to create a synchronous XHR for" << reqUrl;
345 kWarning(7044) << "REASON:" << kioJob->errorString();
346 reply = new KDEPrivate::AccessManagerReply(op, req, QNetworkReply::UnknownNetworkError, kioJob->errorText(), this);
347 }
348 } else {
349 // Set the window on the the KIO ui delegate
350 if (d->window) {
351 kioJob->ui()->setWindow(d->window);
352 }
353
354 // Disable internal automatic redirection handling
355 kioJob->setRedirectionHandlingEnabled(false);
356
357 // Set the job priority
358 switch (req.priority()) {
359 case QNetworkRequest::HighPriority:
360 KIO::Scheduler::setJobPriority(kioJob, -5);
361 break;
362 case QNetworkRequest::LowPriority:
363 KIO::Scheduler::setJobPriority(kioJob, 5);
364 break;
365 default:
366 break;
367 }
368
369 // Set the meta data for this job...
370 kioJob->setMetaData(metaData);
371
372 // Create the reply...
373 reply = new KDEPrivate::AccessManagerReply(op, req, kioJob, d->emitReadyReadOnMetaDataChange, this);
374 //kDebug(7044) << reply << reqUrl;
375 }
376
377 if (ignoreContentDisposition && reply) {
378 //kDebug(7044) << "Content-Disposition WILL BE IGNORED!";
379 reply->setIgnoreContentDisposition(ignoreContentDisposition);
380 }
381
382 return reply;
383}
384
385void AccessManager::AccessManagerPrivate::setMetaDataForRequest(QNetworkRequest request, KIO::MetaData& metaData)
386{
387 // Add any meta data specified within request...
388 QVariant userMetaData = request.attribute (static_cast<QNetworkRequest::Attribute>(MetaData));
389 if (userMetaData.isValid() && userMetaData.type() == QVariant::Map)
390 metaData += userMetaData.toMap();
391
392 metaData.insert(QL1S("PropagateHttpHeader"), QL1S("true"));
393
394 if (request.hasRawHeader("User-Agent")) {
395 metaData.insert(QL1S("UserAgent"), request.rawHeader("User-Agent"));
396 request.setRawHeader("User-Agent", QByteArray());
397 }
398
399 if (request.hasRawHeader("Accept")) {
400 metaData.insert(QL1S("accept"), request.rawHeader("Accept"));
401 request.setRawHeader("Accept", QByteArray());
402 }
403
404 if (request.hasRawHeader("Accept-Charset")) {
405 metaData.insert(QL1S("Charsets"), request.rawHeader("Accept-Charset"));
406 request.setRawHeader("Accept-Charset", QByteArray());
407 }
408
409 if (request.hasRawHeader("Accept-Language")) {
410 metaData.insert(QL1S("Languages"), request.rawHeader("Accept-Language"));
411 request.setRawHeader("Accept-Language", QByteArray());
412 }
413
414 if (request.hasRawHeader("Referer")) {
415 metaData.insert(QL1S("referrer"), request.rawHeader("Referer"));
416 request.setRawHeader("Referer", QByteArray());
417 }
418
419 if (request.hasRawHeader("Content-Type")) {
420 metaData.insert(QL1S("content-type"), request.rawHeader("Content-Type"));
421 request.setRawHeader("Content-Type", QByteArray());
422 }
423
424 if (request.attribute(QNetworkRequest::AuthenticationReuseAttribute) == QNetworkRequest::Manual) {
425 metaData.insert(QL1S("no-preemptive-auth-reuse"), QL1S("true"));
426 }
427
428 request.setRawHeader("Content-Length", QByteArray());
429 request.setRawHeader("Connection", QByteArray());
430 request.setRawHeader("If-None-Match", QByteArray());
431 request.setRawHeader("If-Modified-Since", QByteArray());
432 request.setRawHeader("x-kdewebkit-ignore-disposition", QByteArray());
433
434 QStringList customHeaders;
435 Q_FOREACH(const QByteArray &key, request.rawHeaderList()) {
436 const QByteArray value = request.rawHeader(key);
437 if (value.length())
438 customHeaders << (key + QL1S(": ") + value);
439 }
440
441 if (!customHeaders.isEmpty()) {
442 metaData.insert(QL1S("customHTTPHeader"), customHeaders.join("\r\n"));
443 }
444
445 // Append per request meta data, if any...
446 if (!requestMetaData.isEmpty()) {
447 metaData += requestMetaData;
448 // Clear per request meta data...
449 requestMetaData.clear();
450 }
451
452 // Append per session meta data, if any...
453 if (!sessionMetaData.isEmpty()) {
454 metaData += sessionMetaData;
455 }
456}
457
458
459using namespace KIO::Integration;
460
461static QSsl::SslProtocol qSslProtocolFromString(const QString& str)
462{
463 if (str.compare(QLatin1String("SSLv3"), Qt::CaseInsensitive) == 0) {
464 return QSsl::SslV3;
465 }
466
467 if (str.compare(QLatin1String("SSLv2"), Qt::CaseInsensitive) == 0) {
468 return QSsl::SslV2;
469 }
470
471 if (str.compare(QLatin1String("TLSv1"), Qt::CaseInsensitive) == 0) {
472 return QSsl::TlsV1;
473 }
474
475 return QSsl::AnyProtocol;
476}
477
478bool KIO::Integration::sslConfigFromMetaData(const KIO::MetaData& metadata, QSslConfiguration& sslconfig)
479{
480 bool success = false;
481
482 if (metadata.value(QL1S("ssl_in_use")) == QL1S("TRUE")) {
483 const QSsl::SslProtocol sslProto = qSslProtocolFromString(metadata.value(QL1S("ssl_protocol_version")));
484 QList<QSslCipher> cipherList;
485 cipherList << QSslCipher(metadata.value(QL1S("ssl_cipher_name")), sslProto);
486 sslconfig.setCaCertificates(QSslCertificate::fromData(metadata.value(QL1S("ssl_peer_chain")).toUtf8()));
487 sslconfig.setCiphers(cipherList);
488 sslconfig.setProtocol(sslProto);
489 success = sslconfig.isNull();
490 }
491
492 return success;
493}
494
495CookieJar::CookieJar(QObject* parent)
496 :QNetworkCookieJar(parent), d(new CookieJar::CookieJarPrivate)
497{
498 reparseConfiguration();
499}
500
501CookieJar::~CookieJar()
502{
503 delete d;
504}
505
506WId CookieJar::windowId() const
507{
508 return d->windowId;
509}
510
511bool CookieJar::isCookieStorageDisabled() const
512{
513 return d->isStorageDisabled;
514}
515
516QList<QNetworkCookie> CookieJar::cookiesForUrl(const QUrl &url) const
517{
518 QList<QNetworkCookie> cookieList;
519
520 if (!d->isEnabled) {
521 return cookieList;
522 }
523 QDBusInterface kcookiejar("org.kde.kded", "/modules/kcookiejar", "org.kde.KCookieServer");
524 QDBusReply<QString> reply = kcookiejar.call("findDOMCookies", url.toString(QUrl::RemoveUserInfo), (qlonglong)d->windowId);
525
526 if (!reply.isValid()) {
527 kWarning(7044) << "Unable to communicate with the cookiejar!";
528 return cookieList;
529 }
530
531 const QString cookieStr = reply.value();
532 const QStringList cookies = cookieStr.split(QL1S("; "), QString::SkipEmptyParts);
533 Q_FOREACH(const QString& cookie, cookies) {
534 const int index = cookie.indexOf(QL1C('='));
535 const QString name = cookie.left(index);
536 const QString value = cookie.right((cookie.length() - index - 1));
537 cookieList << QNetworkCookie(name.toUtf8(), value.toUtf8());
538 //kDebug(7044) << "cookie: name=" << name << ", value=" << value;
539 }
540
541 return cookieList;
542}
543
544bool CookieJar::setCookiesFromUrl(const QList<QNetworkCookie> &cookieList, const QUrl &url)
545{
546 if (!d->isEnabled) {
547 return false;
548 }
549
550 QDBusInterface kcookiejar("org.kde.kded", "/modules/kcookiejar", "org.kde.KCookieServer");
551 Q_FOREACH(const QNetworkCookie &cookie, cookieList) {
552 QByteArray cookieHeader ("Set-Cookie: ");
553 if (d->isStorageDisabled && !cookie.isSessionCookie()) {
554 QNetworkCookie sessionCookie(cookie);
555 sessionCookie.setExpirationDate(QDateTime());
556 cookieHeader += sessionCookie.toRawForm();
557 } else {
558 cookieHeader += cookie.toRawForm();
559 }
560 kcookiejar.call("addCookies", url.toString(QUrl::RemoveUserInfo), cookieHeader, (qlonglong)d->windowId);
561 //kDebug(7044) << "[" << d->windowId << "]" << cookieHeader << " from " << url;
562 }
563
564 return !kcookiejar.lastError().isValid();
565}
566
567void CookieJar::setDisableCookieStorage(bool disable)
568{
569 d->isStorageDisabled = disable;
570}
571
572void CookieJar::setWindowId(WId id)
573{
574 d->windowId = id;
575}
576
577void CookieJar::reparseConfiguration()
578{
579 KConfigGroup cfg = KSharedConfig::openConfig("kcookiejarrc", KConfig::NoGlobals)->group("Cookie Policy");
580 d->isEnabled = cfg.readEntry("Cookies", true);
581}
582
583#include "accessmanager.moc"
584
qSslProtocolFromString
static QSsl::SslProtocol qSslProtocolFromString(const QString &str)
Definition: accessmanager.cpp:461
QL1S
#define QL1S(x)
Definition: accessmanager.cpp:51
QL1C
#define QL1C(x)
Definition: accessmanager.cpp:52
gSynchronousNetworkRequestAttribute
static QNetworkRequest::Attribute gSynchronousNetworkRequestAttribute
Definition: accessmanager.cpp:57
sizeFromRequest
static qint64 sizeFromRequest(const QNetworkRequest &req)
Definition: accessmanager.cpp:63
accessmanager.h
accessmanagerreply_p.h
KConfigGroup
KConfigGroup::readEntry
QString readEntry(const char *key, const char *aDefault=0) const
KConfig::NoGlobals
NoGlobals
KDEPrivate::AccessManagerReply
Used for KIO::AccessManager; KDE implementation of QNetworkReply.
Definition: accessmanagerreply_p.h:49
KDEPrivate::AccessManagerReply::isLocalRequest
static bool isLocalRequest(const KUrl &url)
KDEPrivate::AccessManagerReply::putOnHold
void putOnHold()
KDEPrivate::AccessManagerReply::setIgnoreContentDisposition
void setIgnoreContentDisposition(bool on)
KIO::AccessManager
A KDE implementation of QNetworkAccessManager.
Definition: accessmanager.h:74
KIO::AccessManager::setEmitReadyReadOnMetaDataChange
void setEmitReadyReadOnMetaDataChange(bool)
Sets the network reply object to emit readyRead when it receives meta data.
Definition: accessmanager.cpp:208
KIO::AccessManager::isExternalContentAllowed
bool isExternalContentAllowed() const
Returns true if external content is going to be fetched.
Definition: accessmanager.cpp:132
KIO::AccessManager::setWindow
void setWindow(QWidget *widget)
Sets the window associated with this network access manager.
Definition: accessmanager.cpp:154
KIO::AccessManager::cookieJarWindowid
WId cookieJarWindowid() const
Returns the cookiejar's window id.
Definition: accessmanager.cpp:173
KIO::AccessManager::createRequest
virtual QNetworkReply * createRequest(Operation op, const QNetworkRequest &req, QIODevice *outgoingData=0)
Reimplemented for internal reasons, the API is not affected.
Definition: accessmanager.cpp:213
KIO::AccessManager::AccessManager
AccessManager(QObject *parent)
Constructor.
Definition: accessmanager.cpp:115
KIO::AccessManager::setExternalContentAllowed
void setExternalContentAllowed(bool allowed)
Set allowed to false if you don't want any external content to be fetched.
Definition: accessmanager.cpp:127
KIO::AccessManager::~AccessManager
virtual ~AccessManager()
Destructor.
Definition: accessmanager.cpp:122
KIO::AccessManager::window
QWidget * window() const
Returns the window associated with this network access manager.
Definition: accessmanager.cpp:183
KIO::AccessManager::putReplyOnHold
static void putReplyOnHold(QNetworkReply *reply)
Puts the ioslave associated with the given reply on hold.
Definition: accessmanager.cpp:198
KIO::AccessManager::setCookieJarWindowId
void setCookieJarWindowId(WId id)
Sets the cookiejar's window id to id.
Definition: accessmanager.cpp:138
KIO::AccessManager::requestMetaData
KIO::MetaData & requestMetaData()
Returns a reference to the temporary meta data container.
Definition: accessmanager.cpp:188
KIO::AccessManager::sessionMetaData
KIO::MetaData & sessionMetaData()
Returns a reference to the persistent meta data container.
Definition: accessmanager.cpp:193
KIO::Integration::CookieJar
A KDE implementation of QNetworkCookieJar.
Definition: accessmanager.h:279
KIO::Integration::CookieJar::isCookieStorageDisabled
bool isCookieStorageDisabled() const
Returns true if persistent caching of cookies is disabled.
Definition: accessmanager.cpp:511
KIO::Integration::CookieJar::setDisableCookieStorage
void setDisableCookieStorage(bool disable)
Prevent persistent storage of cookies.
Definition: accessmanager.cpp:567
KIO::Integration::CookieJar::reparseConfiguration
void reparseConfiguration()
Reparse the KDE cookiejar configuration file.
Definition: accessmanager.cpp:577
KIO::Integration::CookieJar::setWindowId
void setWindowId(WId id)
Sets the window id of the application.
Definition: accessmanager.cpp:572
KIO::Integration::CookieJar::windowId
WId windowId() const
Returns the currently set window id.
Definition: accessmanager.cpp:506
KIO::Integration::CookieJar::setCookiesFromUrl
bool setCookiesFromUrl(const QList< QNetworkCookie > &cookieList, const QUrl &url)
Reimplemented for internal reasons, the API is not affected.
Definition: accessmanager.cpp:544
KIO::Integration::CookieJar::~CookieJar
~CookieJar()
Destroys the KNetworkCookieJar.
Definition: accessmanager.cpp:501
KIO::Integration::CookieJar::CookieJar
CookieJar(QObject *parent=0)
Constructs a KNetworkCookieJar with parent parent.
Definition: accessmanager.cpp:495
KIO::Integration::CookieJar::cookiesForUrl
QList< QNetworkCookie > cookiesForUrl(const QUrl &url) const
Reimplemented for internal reasons, the API is not affected.
Definition: accessmanager.cpp:516
KIO::JobUiDelegate::setWindow
virtual void setWindow(QWidget *window)
Associate this job with a window given by window.
Definition: jobuidelegate.cpp:58
KIO::Job::setMetaData
void setMetaData(const KIO::MetaData &metaData)
Set meta data to be sent to the slave, replacing existing meta data.
Definition: job.cpp:258
KIO::Job::errorString
QString errorString() const
Converts an error code and a non-i18n error message into an error message in the current language.
Definition: global.cpp:159
KIO::Job::ui
JobUiDelegate * ui() const
Retrieves the UI delegate of this job.
Definition: job.cpp:90
KIO::MetaData
MetaData is a simple map of key/value strings.
Definition: global.h:397
KIO::NetAccess::synchronousRun
static bool synchronousRun(Job *job, QWidget *window, QByteArray *data=0, KUrl *finalURL=0, QMap< QString, QString > *metaData=0)
This function executes a job in a synchronous way.
Definition: netaccess.cpp:276
KIO::Scheduler::setJobPriority
static void setJobPriority(SimpleJob *job, int priority)
Changes the priority of job; jobs of the same priority run in the order in which they were created.
Definition: scheduler.cpp:805
KIO::SimpleJob
A simple job (one url and one command).
Definition: jobclasses.h:322
KIO::SimpleJob::setRedirectionHandlingEnabled
void setRedirectionHandlingEnabled(bool handle)
Set handle to false to prevent the internal handling of redirections.
Definition: job.cpp:369
KJob::errorText
QString errorText() const
KSharedConfig::openConfig
static KSharedConfig::Ptr openConfig(const KComponentData &componentData, const QString &fileName=QString(), OpenFlags mode=FullConfig, const char *resourceType="config")
KUrl
KUrl::path
QString path(AdjustPathOption trailing=LeaveTrailingSlash) const
QIODevice
QList
QNetworkAccessManager
QNetworkCookieJar
QNetworkReply
QObject
QUrl
QWidget
header
const char header[]
kDebug
#define kDebug
kWarning
#define kWarning
job.h
jobuidelegate.h
kconfiggroup.h
kdebug.h
klocalizedstring.h
i18n
QString i18n(const char *text)
kprotocolinfo.h
ksharedconfig.h
KIO::Integration
Definition: accessmanager.cpp:93
KIO::Integration::sslConfigFromMetaData
bool sslConfigFromMetaData(const KIO::MetaData &metadata, QSslConfiguration &sslconfig)
Maps KIO SSL meta data into the given QSslConfiguration object.
Definition: accessmanager.cpp:478
KIO
A namespace for KIO globals.
Definition: kbookmarkmenu.h:55
KIO::http_post
TransferJob * http_post(const KUrl &url, const QByteArray &postData, JobFlags flags=DefaultFlags)
HTTP POST (for form data).
Definition: job.cpp:1597
KIO::stat
StatJob * stat(const KUrl &url, JobFlags flags=DefaultFlags)
Find all details for one file or directory.
Definition: job.cpp:924
KIO::put
TransferJob * put(const KUrl &url, int permissions, JobFlags flags=DefaultFlags)
Put (a.k.a.
Definition: job.cpp:1700
KIO::get
TransferJob * get(const KUrl &url, LoadType reload=NoReload, JobFlags flags=DefaultFlags)
Get (a.k.a.
Definition: job.cpp:1369
KIO::NoReload
@ NoReload
Definition: job.h:29
KIO::mimetype
MimetypeJob * mimetype(const KUrl &url, JobFlags flags=DefaultFlags)
Find mimetype for one file or directory.
Definition: job.cpp:1856
KIO::HideProgressInfo
@ HideProgressInfo
Hide progress information dialog, i.e.
Definition: jobclasses.h:51
KIO::http_delete
TransferJob * http_delete(const KUrl &url, JobFlags flags=DefaultFlags)
HTTP DELETE.
Definition: job.cpp:1637
name
const char * name(StandardAction id)
ok
KGuiItem ok()
netaccess.h
scheduler.h
This file is part of the KDE documentation.
Documentation copyright © 1996-2023 The KDE developers.
Generated on Mon Feb 20 2023 00:00:00 by doxygen 1.9.6 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

KIO

Skip menu "KIO"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members
  • Related Pages

kdelibs-4.14.38 API Reference

Skip menu "kdelibs-4.14.38 API Reference"
  • DNSSD
  • Interfaces
  •   KHexEdit
  •   KMediaPlayer
  •   KSpeech
  •   KTextEditor
  • kconf_update
  • KDE3Support
  •   KUnitTest
  • KDECore
  • KDED
  • KDEsu
  • KDEUI
  • KDEWebKit
  • KDocTools
  • KFile
  • KHTML
  • KImgIO
  • KInit
  • kio
  • KIOSlave
  • KJS
  •   KJS-API
  •   WTF
  • kjsembed
  • KNewStuff
  • KParts
  • KPty
  • Kross
  • KUnitConversion
  • KUtils
  • Nepomuk
  • Plasma
  • Solid
  • Sonnet
  • ThreadWeaver
Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal