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

KIOSlave

  • kioslave
  • http
  • kcookiejar
kcookieserver.cpp
Go to the documentation of this file.
1/*
2This file is part of KDE
3
4 Copyright (C) 1998-2000 Waldo Bastian (bastian@kde.org)
5
6Permission is hereby granted, free of charge, to any person obtaining a copy
7of this software and associated documentation files (the "Software"), to deal
8in the Software without restriction, including without limitation the rights
9to use, copy, modify, merge, publish, distribute, and/or sell
10copies of the Software, and to permit persons to whom the Software is
11furnished to do so, subject to the following conditions:
12
13The above copyright notice and this permission notice shall be included in
14all copies or substantial portions of the Software.
15
16THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
20AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
21CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
22 */
23//----------------------------------------------------------------------------
24//
25// KDE Cookie Server
26
27#include "kcookieserver.h"
28
29#define SAVE_DELAY 3 // Save after 3 minutes
30
31#include <QtCore/QTimer>
32#include <QtCore/QFile>
33#include <QtDBus/QtDBus>
34
35#include <kconfig.h>
36#include <kdebug.h>
37#include <kcmdlineargs.h>
38#include <kstandarddirs.h>
39#include <kpluginfactory.h>
40#include <kpluginloader.h>
41#include <kwindowsystem.h>
42
43#include "kcookiejar.h"
44#include "kcookiewin.h"
45#include "kcookieserveradaptor.h"
46
47#define QL1S(x) QLatin1String(x)
48#define QL1C(x) QLatin1Char(x)
49
50K_PLUGIN_FACTORY(KdedCookieServerFactory,
51 registerPlugin<KCookieServer>();
52 )
53K_EXPORT_PLUGIN(KdedCookieServerFactory("kcookiejar"))
54
55// Cookie field indexes
56enum CookieDetails { CF_DOMAIN=0, CF_PATH, CF_NAME, CF_HOST,
57 CF_VALUE, CF_EXPIRE, CF_PROVER, CF_SECURE };
58
59
60class CookieRequest {
61public:
62 QDBusMessage reply;
63 QString url;
64 bool DOM;
65 qlonglong windowId;
66};
67
68template class QList<CookieRequest*>;
69
70class RequestList : public QList<CookieRequest*>
71{
72public:
73 RequestList() : QList<CookieRequest*>() { }
74};
75
76KCookieServer::KCookieServer(QObject* parent, const QList<QVariant>&)
77 : KDEDModule(parent)
78{
79 (void)new KCookieServerAdaptor(this);
80 mCookieJar = new KCookieJar;
81 mPendingCookies = new KHttpCookieList;
82 mRequestList = new RequestList;
83 mAdvicePending = false;
84 mTimer = new QTimer();
85 mTimer->setSingleShot(true);
86 connect(mTimer, SIGNAL(timeout()), SLOT(slotSave()));
87 mConfig = new KConfig("kcookiejarrc");
88 mCookieJar->loadConfig( mConfig );
89
90 const QString filename = KStandardDirs::locateLocal("data", "kcookiejar/cookies");
91
92 // Stay backwards compatible!
93 const QString filenameOld = KStandardDirs::locate("data", "kfm/cookies");
94 if (!filenameOld.isEmpty())
95 {
96 mCookieJar->loadCookies( filenameOld );
97 if (mCookieJar->saveCookies( filename))
98 {
99 QFile::remove(filenameOld); // Remove old kfm cookie file
100 }
101 }
102 else
103 {
104 mCookieJar->loadCookies( filename);
105 }
106 connect(this, SIGNAL(windowUnregistered(qlonglong)),
107 this, SLOT(slotDeleteSessionCookies(qlonglong)));
108}
109
110KCookieServer::~KCookieServer()
111{
112 slotSave();
113 delete mCookieJar;
114 delete mTimer;
115 delete mPendingCookies;
116 delete mConfig;
117}
118
119bool KCookieServer::cookiesPending( const QString &url, KHttpCookieList *cookieList )
120{
121 QString fqdn;
122 QString path;
123 // Check whether 'url' has cookies on the pending list
124 if (mPendingCookies->isEmpty())
125 return false;
126 if (!KCookieJar::parseUrl(url, fqdn, path))
127 return false;
128
129 QStringList domains;
130 mCookieJar->extractDomains(fqdn, domains);
131 Q_FOREACH(const KHttpCookie& cookie, *mPendingCookies) {
132 if (cookie.match( fqdn, domains, path)) {
133 if (!cookieList)
134 return true;
135 cookieList->append(cookie);
136 }
137 }
138 if (!cookieList)
139 return false;
140 return cookieList->isEmpty();
141}
142
143void KCookieServer::addCookies( const QString &url, const QByteArray &cookieHeader,
144 qlonglong windowId, bool useDOMFormat )
145{
146 KHttpCookieList cookieList;
147 if (useDOMFormat)
148 cookieList = mCookieJar->makeDOMCookies(url, cookieHeader, windowId);
149 else
150 cookieList = mCookieJar->makeCookies(url, cookieHeader, windowId);
151
152 checkCookies(&cookieList, windowId);
153
154 *mPendingCookies += cookieList;
155
156 if (!mAdvicePending)
157 {
158 mAdvicePending = true;
159 while (!mPendingCookies->isEmpty())
160 {
161 checkCookies(0, windowId);
162 }
163 mAdvicePending = false;
164 }
165}
166
167void KCookieServer::checkCookies(KHttpCookieList *cookieList)
168{
169 checkCookies(cookieList, 0);
170}
171
172void KCookieServer::checkCookies(KHttpCookieList *cookieList, qlonglong windowId)
173{
174 KHttpCookieList *list;
175
176 if (cookieList)
177 list = cookieList;
178 else
179 list = mPendingCookies;
180
181 QMutableListIterator<KHttpCookie> cookieIterator(*list);
182 while (cookieIterator.hasNext()) {
183 KHttpCookie& cookie = cookieIterator.next();
184 const KCookieAdvice advice = mCookieJar->cookieAdvice(cookie);
185 switch(advice) {
186 case KCookieAccept:
187 case KCookieAcceptForSession:
188 mCookieJar->addCookie(cookie);
189 cookieIterator.remove();
190 break;
191 case KCookieReject:
192 cookieIterator.remove();
193 break;
194 default:
195 break;
196 }
197 }
198
199 if (cookieList || list->isEmpty())
200 return;
201
202 // Collect all pending cookies with the same host as the first pending cookie
203 const KHttpCookie& currentCookie = mPendingCookies->first();
204 KHttpCookieList currentList;
205 currentList.append(currentCookie);
206 const QString currentHost = currentCookie.host();
207 QList<int> shownCookies; shownCookies << 0;
208 for (int i = 1 /*first already done*/; i < mPendingCookies->count(); ++i) {
209 const KHttpCookie& cookie = (*mPendingCookies)[i];
210 if (cookie.host() == currentHost) {
211 currentList.append(cookie);
212 shownCookies << i;
213 }
214 }
215 //kDebug() << shownCookies;
216
217 KCookieWin *kw = new KCookieWin( 0L, currentList,
218 mCookieJar->preferredDefaultPolicy(),
219 mCookieJar->showCookieDetails() );
220 if (windowId > 0) {
221#ifndef Q_WS_WIN
222 KWindowSystem::setMainWindow(kw, static_cast<WId>(windowId));
223#else
224 KWindowSystem::setMainWindow(kw, (HWND)(long)windowId);
225#endif
226 }
227
228 KCookieAdvice userAdvice = kw->advice(mCookieJar, currentCookie);
229 delete kw;
230 // Save the cookie config if it has changed
231 mCookieJar->saveConfig( mConfig );
232
233 // Apply the user's choice to all cookies that are currently
234 // queued for this host (or just the first one, if the user asks for that).
235 QMutableListIterator<KHttpCookie> cookieIterator2(*mPendingCookies);
236 int pendingCookieIndex = -1;
237 while (cookieIterator2.hasNext()) {
238 ++pendingCookieIndex;
239 KHttpCookie& cookie = cookieIterator2.next();
240 if (cookie.host() != currentHost)
241 continue;
242 if (mCookieJar->preferredDefaultPolicy() == KCookieJar::ApplyToShownCookiesOnly
243 && !shownCookies.contains(pendingCookieIndex)) {
244 // User chose "only those cookies", and this one was added while the dialog was up -> skip
245 break;
246 }
247 switch(userAdvice) {
248 case KCookieAccept:
249 case KCookieAcceptForSession:
250 // Store the user's choice for the cookie.
251 // This is only used to check later if the cookie should expire
252 // at the end of the session. The choice is not saved on disk.
253 cookie.setUserSelectedAdvice(userAdvice);
254 mCookieJar->addCookie(cookie);
255 cookieIterator2.remove();
256 break;
257
258 case KCookieReject:
259 cookieIterator2.remove();
260 break;
261
262 default:
263 kWarning() << "userAdvice not accept or reject, this should never happen!";
264 break;
265 }
266 }
267
268 // Check if we can handle any request
269 QMutableListIterator<CookieRequest *> requestIterator(*mRequestList);
270 while (requestIterator.hasNext()) {
271 CookieRequest *request = requestIterator.next();
272 if (!cookiesPending(request->url)) {
273 const QString res = mCookieJar->findCookies(request->url, request->DOM, request->windowId);
274
275 QDBusConnection::sessionBus().send(request->reply.createReply(res));
276 delete request;
277 requestIterator.remove();
278 }
279 }
280
281 saveCookieJar();
282}
283
284void KCookieServer::slotSave()
285{
286 if (mCookieJar->changed())
287 {
288 QString filename = KStandardDirs::locateLocal("data", "kcookiejar/cookies");
289 mCookieJar->saveCookies(filename);
290 }
291}
292
293void KCookieServer::saveCookieJar()
294{
295 if( mTimer->isActive() )
296 return;
297
298 mTimer->start( 1000*60*SAVE_DELAY );
299}
300
301void KCookieServer::putCookie( QStringList& out, const KHttpCookie& cookie,
302 const QList<int>& fields )
303{
304 foreach ( int i, fields ) {
305 switch(i)
306 {
307 case CF_DOMAIN :
308 out << cookie.domain();
309 break;
310 case CF_NAME :
311 out << cookie.name();
312 break;
313 case CF_PATH :
314 out << cookie.path();
315 break;
316 case CF_HOST :
317 out << cookie.host();
318 break;
319 case CF_VALUE :
320 out << cookie.value();
321 break;
322 case CF_EXPIRE :
323 out << QString::number(cookie.expireDate());
324 break;
325 case CF_PROVER :
326 out << QString::number(cookie.protocolVersion());
327 break;
328 case CF_SECURE :
329 out << QString::number(cookie.isSecure() ? 1 : 0);
330 break;
331 default :
332 out << QString();
333 }
334 }
335}
336
337bool KCookieServer::cookieMatches(const KHttpCookie& c,
338 const QString &domain, const QString &fqdn,
339 const QString &path, const QString &name)
340{
341 const bool hasDomain = !domain.isEmpty();
342 return (((hasDomain && c.domain() == domain) || fqdn == c.host()) &&
343 (c.path() == path) && (c.name() == name) &&
344 (!c.isExpired()));
345}
346
347
348// DBUS function
349QString KCookieServer::listCookies(const QString &url)
350{
351 return findCookies(url, 0);
352}
353
354// DBUS function
355QString KCookieServer::findCookies(const QString &url, qlonglong windowId)
356{
357 if (cookiesPending(url))
358 {
359 CookieRequest *request = new CookieRequest;
360 message().setDelayedReply(true);
361 request->reply = message();
362 request->url = url;
363 request->DOM = false;
364 request->windowId = windowId;
365 mRequestList->append( request );
366 return QString(); // Talk to you later :-)
367 }
368
369 QString cookies = mCookieJar->findCookies(url, false, windowId);
370 saveCookieJar();
371 return cookies;
372}
373
374// DBUS function
375QStringList
376KCookieServer::findDomains()
377{
378 QStringList result;
379 Q_FOREACH(const QString& domain, mCookieJar->getDomainList())
380 {
381 // Ignore domains that have policy set for but contain
382 // no cookies whatsoever...
383 const KHttpCookieList* list = mCookieJar->getCookieList(domain, "");
384 if ( list && !list->isEmpty() )
385 result << domain;
386 }
387 return result;
388}
389
390// DBUS function
391QStringList
392KCookieServer::findCookies(const QList<int> &fields,
393 const QString &_domain,
394 const QString &fqdn,
395 const QString &path,
396 const QString &name)
397{
398 QStringList result;
399 const bool allCookies = name.isEmpty();
400 const QStringList domainList = _domain.split(QLatin1Char(' '));
401
402 if (allCookies)
403 {
404 Q_FOREACH(const QString& domain, domainList)
405 {
406 const KHttpCookieList* list = mCookieJar->getCookieList(domain, fqdn);
407 if (!list)
408 continue;
409 Q_FOREACH(const KHttpCookie& cookie, *list)
410 {
411 if (cookie.isExpired())
412 continue;
413 putCookie(result, cookie, fields);
414 }
415 }
416 }
417 else
418 {
419 Q_FOREACH(const QString& domain, domainList)
420 {
421 const KHttpCookieList* list = mCookieJar->getCookieList(domain, fqdn);
422 if (!list)
423 continue;
424 Q_FOREACH(const KHttpCookie& cookie, *list)
425 {
426 if (cookie.isExpired())
427 continue;
428 if (cookieMatches(cookie, domain, fqdn, path, name))
429 {
430 putCookie(result, cookie, fields);
431 break;
432 }
433 }
434 }
435 }
436
437 return result;
438}
439
440// DBUS function
441QString
442KCookieServer::findDOMCookies(const QString &url)
443{
444 return findDOMCookies(url, 0);
445}
446
447// DBUS function
448QString
449KCookieServer::findDOMCookies(const QString &url, qlonglong windowId)
450{
451 // We don't wait for pending cookies because it locks up konqueror
452 // which can cause a deadlock if it happens to have a popup-menu up.
453 // Instead we just return pending cookies as if they had been accepted already.
454 KHttpCookieList pendingCookies;
455 cookiesPending(url, &pendingCookies);
456
457 return mCookieJar->findCookies(url, true, windowId, &pendingCookies);
458}
459
460// DBUS function
461void
462KCookieServer::addCookies(const QString &arg1, const QByteArray &arg2, qlonglong arg3)
463{
464 addCookies(arg1, arg2, arg3, false);
465}
466
467// DBUS function
468void
469KCookieServer::deleteCookie(const QString &domain, const QString &fqdn,
470 const QString &path, const QString &name)
471{
472 KHttpCookieList* cookieList = mCookieJar->getCookieList( domain, fqdn );
473 if (cookieList && !cookieList->isEmpty()) {
474 KHttpCookieList::Iterator itEnd = cookieList->end();
475 for (KHttpCookieList::Iterator it = cookieList->begin(); it != itEnd; ++it)
476 {
477 if (cookieMatches(*it, domain, fqdn, path, name)) {
478 mCookieJar->eatCookie(it);
479 saveCookieJar();
480 break;
481 }
482 }
483 }
484}
485
486// DBUS function
487void
488KCookieServer::deleteCookiesFromDomain(const QString &domain)
489{
490 mCookieJar->eatCookiesForDomain(domain);
491 saveCookieJar();
492}
493
494
495// Qt function
496void
497KCookieServer::slotDeleteSessionCookies( qlonglong windowId )
498{
499 deleteSessionCookies(windowId);
500}
501
502// DBUS function
503void
504KCookieServer::deleteSessionCookies( qlonglong windowId )
505{
506 mCookieJar->eatSessionCookies( windowId );
507 saveCookieJar();
508}
509
510void
511KCookieServer::deleteSessionCookiesFor(const QString &fqdn, qlonglong windowId)
512{
513 mCookieJar->eatSessionCookies( fqdn, windowId );
514 saveCookieJar();
515}
516
517// DBUS function
518void
519KCookieServer::deleteAllCookies()
520{
521 mCookieJar->eatAllCookies();
522 saveCookieJar();
523}
524
525// DBUS function
526void
527KCookieServer::addDOMCookies(const QString &url, const QByteArray &cookieHeader, qlonglong windowId)
528{
529 addCookies(url, cookieHeader, windowId, true);
530}
531
532// DBUS function
533bool
534KCookieServer::setDomainAdvice(const QString &url, const QString &advice)
535{
536 QString fqdn;
537 QString dummy;
538 if (KCookieJar::parseUrl(url, fqdn, dummy))
539 {
540 QStringList domains;
541 mCookieJar->extractDomains(fqdn, domains);
542
543 mCookieJar->setDomainAdvice(domains[domains.count() > 3 ? 3 : 0],
544 KCookieJar::strToAdvice(advice));
545 // Save the cookie config if it has changed
546 mCookieJar->saveConfig( mConfig );
547 return true;
548 }
549 return false;
550}
551
552// DBUS function
553QString
554KCookieServer::getDomainAdvice(const QString &url)
555{
556 KCookieAdvice advice = KCookieDunno;
557 QString fqdn;
558 QString dummy;
559 if (KCookieJar::parseUrl(url, fqdn, dummy))
560 {
561 QStringList domains;
562 mCookieJar->extractDomains(fqdn, domains);
563
564 QStringListIterator it (domains);
565 while ( (advice == KCookieDunno) && it.hasNext() )
566 {
567 // Always check advice in both ".domain" and "domain". Note
568 // that we only want to check "domain" if it matches the
569 // fqdn of the requested URL.
570 const QString& domain = it.next();
571 if ( domain.at(0) == '.' || domain == fqdn )
572 advice = mCookieJar->getDomainAdvice(domain);
573 }
574 if (advice == KCookieDunno)
575 advice = mCookieJar->getGlobalAdvice();
576 }
577 return KCookieJar::adviceToStr(advice);
578}
579
580// DBUS function
581void
582KCookieServer::reloadPolicy()
583{
584 mCookieJar->loadConfig( mConfig, true );
585}
586
587// DBUS function
588void
589KCookieServer::shutdown()
590{
591 deleteLater();
592}
593
594#include "kcookieserver.moc"
595
KConfig
KCookieJar
Definition: kcookiejar.h:130
KCookieJar::eatSessionCookies
void eatSessionCookies(long windowId)
Removes all end of session cookies set by the session windId.
Definition: kcookiejar.cpp:1196
KCookieJar::getCookieList
KHttpCookieList * getCookieList(const QString &_domain, const QString &_fqdn)
Get a list of all cookies in the cookie jar originating from _domain.
Definition: kcookiejar.cpp:1144
KCookieJar::getDomainAdvice
KCookieAdvice getDomainAdvice(const QString &_domain) const
This function gets the advice for all cookies originating from _domain.
Definition: kcookiejar.cpp:1063
KCookieJar::strToAdvice
static KCookieAdvice strToAdvice(const QString &_str)
Definition: kcookiejar.cpp:143
KCookieJar::extractDomains
void extractDomains(const QString &_fqdn, QStringList &_domainList) const
Returns a list of domains in _domainList relevant for this host.
Definition: kcookiejar.cpp:594
KCookieJar::adviceToStr
static QString adviceToStr(KCookieAdvice _advice)
Definition: kcookiejar.cpp:131
KCookieJar::saveConfig
void saveConfig(KConfig *_config)
Save the cookie configuration.
Definition: kcookiejar.cpp:1494
KCookieJar::saveCookies
bool saveCookies(const QString &_filename)
Store all the cookies in a safe(?) place.
Definition: kcookiejar.cpp:1267
KCookieJar::cookieAdvice
KCookieAdvice cookieAdvice(const KHttpCookie &cookie) const
This function advices whether a single KHttpCookie object should be added to the cookie jar.
Definition: kcookiejar.cpp:1010
KCookieJar::eatCookie
void eatCookie(KHttpCookieList::iterator cookieIterator)
Remove & delete a cookie from the jar.
Definition: kcookiejar.cpp:1161
KCookieJar::getDomainList
const QStringList & getDomainList()
Get a list of all domains known to the cookie jar.
Definition: kcookiejar.cpp:1136
KCookieJar::preferredDefaultPolicy
KCookieDefaultPolicy preferredDefaultPolicy() const
Returns the user's choice in the cookie window.
Definition: kcookiejar.h:362
KCookieJar::addCookie
void addCookie(KHttpCookie &cookie)
This function hands a KHttpCookie object over to the cookie jar.
Definition: kcookiejar.cpp:934
KCookieJar::setDomainAdvice
void setDomainAdvice(const QString &_domain, KCookieAdvice _advice)
This function sets the advice for all cookies originating from _domain.
Definition: kcookiejar.cpp:1080
KCookieJar::eatCookiesForDomain
void eatCookiesForDomain(const QString &domain)
Remove & delete all cookies for domain.
Definition: kcookiejar.cpp:1181
KCookieJar::findCookies
QString findCookies(const QString &_url, bool useDOMFormat, long windowId, KHttpCookieList *pendingCookies=0)
Looks for cookies in the cookie jar which are appropriate for _url.
Definition: kcookiejar.cpp:350
KCookieJar::eatAllCookies
void eatAllCookies()
Remove & delete all cookies.
Definition: kcookiejar.cpp:1205
KCookieJar::getGlobalAdvice
KCookieAdvice getGlobalAdvice() const
Get the global advice for cookies.
Definition: kcookiejar.h:280
KCookieJar::loadConfig
void loadConfig(KConfig *_config, bool reparse=false)
Load the cookie configuration.
Definition: kcookiejar.cpp:1527
KCookieJar::loadCookies
bool loadCookies(const QString &_filename)
Load all the cookies from file and add them to the cookie jar.
Definition: kcookiejar.cpp:1390
KCookieJar::makeDOMCookies
KHttpCookieList makeDOMCookies(const QString &_url, const QByteArray &cookie_domstr, long windowId)
This function parses cookie_headers and returns a linked list of valid KHttpCookie objects for all co...
Definition: kcookiejar.cpp:863
KCookieJar::showCookieDetails
bool showCookieDetails() const
Returns the.
Definition: kcookiejar.h:365
KCookieJar::changed
bool changed() const
Returns whether the cookiejar has been changed.
Definition: kcookiejar.h:149
KCookieJar::makeCookies
KHttpCookieList makeCookies(const QString &_url, const QByteArray &cookie_headers, long windowId)
This function parses cookie_headers and returns a linked list of valid KHttpCookie objects for all co...
Definition: kcookiejar.cpp:665
KCookieJar::ApplyToShownCookiesOnly
@ ApplyToShownCookiesOnly
Definition: kcookiejar.h:357
KCookieJar::parseUrl
static bool parseUrl(const QString &_url, QString &_fqdn, QString &_path, int *port=0)
Parses _url and returns the FQDN (_fqdn) and path (_path).
Definition: kcookiejar.cpp:569
KCookieServer::checkCookies
void checkCookies(KHttpCookieList *cookieList)
Definition: kcookieserver.cpp:167
KCookieServer::reloadPolicy
void reloadPolicy()
Definition: kcookieserver.cpp:582
KCookieServer::addCookies
void addCookies(const QString &url, const QByteArray &cookieHeader, qlonglong windowId)
Definition: kcookieserver.cpp:462
KCookieServer::KCookieServer
KCookieServer(QObject *parent, const QList< QVariant > &)
Definition: kcookieserver.cpp:76
KCookieServer::cookiesPending
bool cookiesPending(const QString &url, KHttpCookieList *cookieList=0)
Definition: kcookieserver.cpp:119
KCookieServer::setDomainAdvice
bool setDomainAdvice(const QString &url, const QString &advice)
Sets the cookie policy for the domain associated with the specified URL.
Definition: kcookieserver.cpp:534
KCookieServer::deleteSessionCookies
void deleteSessionCookies(qlonglong windowId)
Definition: kcookieserver.cpp:504
KCookieServer::listCookies
QString listCookies(const QString &url)
Definition: kcookieserver.cpp:349
KCookieServer::findCookies
QString findCookies(const QString &url, qlonglong windowId)
Definition: kcookieserver.cpp:355
KCookieServer::deleteCookie
void deleteCookie(const QString &domain, const QString &fqdn, const QString &path, const QString &name)
Definition: kcookieserver.cpp:469
KCookieServer::getDomainAdvice
QString getDomainAdvice(const QString &url)
Returns the cookie policy in effect for the specified URL.
Definition: kcookieserver.cpp:554
KCookieServer::deleteAllCookies
void deleteAllCookies()
Definition: kcookieserver.cpp:519
KCookieServer::deleteCookiesFromDomain
void deleteCookiesFromDomain(const QString &domain)
Definition: kcookieserver.cpp:488
KCookieServer::shutdown
void shutdown()
Definition: kcookieserver.cpp:589
KCookieServer::findDomains
QStringList findDomains()
Definition: kcookieserver.cpp:376
KCookieServer::deleteSessionCookiesFor
void deleteSessionCookiesFor(const QString &fqdn, qlonglong windowId)
Definition: kcookieserver.cpp:511
KCookieServer::findDOMCookies
QString findDOMCookies(const QString &url)
Definition: kcookieserver.cpp:442
KCookieServer::addDOMCookies
void addDOMCookies(const QString &url, const QByteArray &cookieHeader, qlonglong windowId)
Definition: kcookieserver.cpp:527
KCookieServer::~KCookieServer
~KCookieServer()
Definition: kcookieserver.cpp:110
KCookieWin
Definition: kcookiewin.h:64
KCookieWin::advice
KCookieAdvice advice(KCookieJar *cookiejar, const KHttpCookie &cookie)
Definition: kcookiewin.cpp:186
KDEDModule
KDEDModule::windowUnregistered
void windowUnregistered(qlonglong windowId)
KHttpCookieList
Definition: kcookiejar.h:114
KHttpCookie
Definition: kcookiejar.h:50
KHttpCookie::domain
QString domain() const
Definition: kcookiejar.h:85
KHttpCookie::protocolVersion
int protocolVersion() const
Definition: kcookiejar.h:95
KHttpCookie::match
bool match(const QString &fqdn, const QStringList &domainList, const QString &path, int port=-1) const
Definition: kcookiejar.cpp:238
KHttpCookie::value
QString value() const
Definition: kcookiejar.h:89
KHttpCookie::isExpired
bool isExpired(qint64 currentDate=-1) const
If currentDate is -1, the default, then the current timestamp in UTC is used for comparison against t...
Definition: kcookiejar.cpp:196
KHttpCookie::host
QString host() const
Definition: kcookiejar.h:86
KHttpCookie::isSecure
bool isSecure() const
Definition: kcookiejar.h:96
KHttpCookie::path
QString path() const
Definition: kcookiejar.h:87
KHttpCookie::setUserSelectedAdvice
void setUserSelectedAdvice(KCookieAdvice advice)
Definition: kcookiejar.h:108
KHttpCookie::expireDate
qint64 expireDate() const
Definition: kcookiejar.h:94
KHttpCookie::name
QString name() const
Definition: kcookiejar.h:88
K_EXPORT_PLUGIN
#define K_EXPORT_PLUGIN(factory)
KStandardDirs::locate
static QString locate(const char *type, const QString &filename, const KComponentData &cData=KGlobal::mainComponent())
KStandardDirs::locateLocal
static QString locateLocal(const char *type, const QString &filename, bool createDir, const KComponentData &cData=KGlobal::mainComponent())
KWindowSystem::setMainWindow
static void setMainWindow(QWidget *subwindow, WId mainwindow)
QList
QObject
kWarning
#define kWarning
kcmdlineargs.h
kconfig.h
kcookiejar.h
KCookieAdvice
KCookieAdvice
Definition: kcookiejar.h:41
KCookieAcceptForSession
@ KCookieAcceptForSession
Definition: kcookiejar.h:44
KCookieAccept
@ KCookieAccept
Definition: kcookiejar.h:43
KCookieReject
@ KCookieReject
Definition: kcookiejar.h:45
KCookieDunno
@ KCookieDunno
Definition: kcookiejar.h:42
SAVE_DELAY
#define SAVE_DELAY
Definition: kcookieserver.cpp:29
kcookieserver.h
kcookiewin.h
kdebug.h
timeout
int timeout
kpluginfactory.h
kpluginloader.h
kstandarddirs.h
kwindowsystem.h
message
void message(KMessage::MessageType messageType, const QString &text, const QString &caption=QString())
list
QStringList list(const QString &fileClass)
name
const char * name(StandardAction id)
K_PLUGIN_FACTORY
K_PLUGIN_FACTORY(ProxyScoutFactory, registerPlugin< KPAC::ProxyScout >();) namespace KPAC
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.

KIOSlave

Skip menu "KIOSlave"
  • Main Page
  • 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