Differential D14379 Diff 39241 webenginepart/src/webenginepartcookiejar.h

Changeset View

Standalone View

webenginepart/src/webenginepartcookiejar.h

This file was added.

1		/*
2		* This file is part of the KDE project
3		* Copyright (C) 2018 Stefano Crocco <stefano.crocco@alice.it>
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 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		#ifndef WEBENGINEPARTCOOKIEJAR_H
26		#define WEBENGINEPARTCOOKIEJAR_H
27
28		#include <QObject>
29		#include <QNetworkCookie>
30		#include <QHash>
31		#include <QUrl>
32		#include <QWebEngineCookieStore>
33		#include <QStringList>
34		#include <QVariant>
35		#include <QDebug>
36		#include <QDBusInterface>
37		#include <QSet>
38
39		class QWidget;
40		class QWebEngineProfile;
41
42		/**
43		* @brief Class which takes care of synchronizing Chromium cookies from `QWebEngineCookieStore` with KIO
44		*/
45		class WebEnginePartCookieJar : public QObject
46		{
47		Q_OBJECT
48
49		public:
50
51		/**
52		* @brief Constructor
53		*
54		* @param [in,out] prof the profile containig the store to synchronize with
55		* @param view the view associated with the store. Its only purpose is to obtain the `WinID` for the DBus call to `addCookies`
56		* @param parent the parent object
57		* @note The `PersistentCookiePolicy` of the given profile will be set to `NoPersistentCookies` so that, on application startup,
58		* only cookies from KIO will be inside the store
59		*/
60		WebEnginePartCookieJar(QWebEngineProfile* prof, QObject* parent = Q_NULLPTR);
61
62		/**
63		* @brief Destructor
64		*/
65		~WebEnginePartCookieJar();
66
67		private slots:
68
69		/**
70		* @brief Adds a cookie to KIO
71		*
72		* This slot is called in response to `QWebEngineCookieStore::cookieAdded` signal.
73		*
74		* @param cookie cookie the cookie to add
75		*
76		* @internal KIO requires an URL when adding a cookie; unfortunately, the `cookieAdded` signal doesn't provide one. To solve this problem, an URL is created
77		* by using the scheme of #m_lastRequestOrigin and the cookie's domain. Looking At the source code for `KCookieJar`, an URL built this way should work.
78		* In case the cookie's domain is empty (which I believe shouldn't happen), #m_lastRequestOrigin is used.
79		*
80		* This function also adds the cookie and its corresponding URL to #m_cookiesUrl
81		*/
82		void addCookie(const QNetworkCookie &cookie);
83
84		/**
85		* @brief Removes the given cookie from KIO
86		*
87		* This slot is called in response to `QWebEngineCookieStore::cookieRemoved` signal.
88		*
89		* @param cookie the cookie to remove
90		*
91		* @internal As for addCookie() there's a problem here, because `QWebEngineCookieStore::cookieRemoved` doesn't provide a fqdn for the cookie. This value is obtained
92		* from #m_cookiesUrl.
93		*/
94		void removeCookie(const QNetworkCookie &cookie);
95
96		/**
97		* @brief Removes all session cookies from `KCookieJar`
98		*
99		* This function doesn't remove cookies from the `QWebEngineCookieStore`, because it's meant to be called
100		* when the application is closing, so those cookies will be destroied automatically (because they're only stored
101		* in memory)
102		*
103		*/
104		void deleteSessionCookies();
105
106		private:
107
108		/**
109		* @brief Determine the window ID to pass to `KCookieServer::addCookies`
110		*
111		* There's no sure way to find the window which received a cookie, so this function chooses the active window
112		* if there's one (according to `QApplication::activeWindow`) or the first widget in `QApplication::topLevelWidgets`
113		* for which `QWidget::isWindow` is `true` and which doesn't have a parent.
114		*
115		* @return the ID of the window determined as described above or 0 if no such a window can be found
116		*/
117		static qlonglong findWinID();
118
119		using CookieList = QList<QNetworkCookie>;
120
121		/**
122		* @brief An identifier for a cookie
123		*
124		* The identifier is made by the cookie's name, domain and path
125		*/
126		struct CookieIdentifier{
127
128		/**
129		* @brief Default constructor
130		*/
131		CookieIdentifier(){}
132
133		/**
134		* @brief Constructor
135		*
136		* @param cookie the cookie to create the identifier for
137		*/
138		CookieIdentifier(const QNetworkCookie &cookie);
139
140		/**
141		* @brief Constructor
142		*
143		* @param n the cookie's name
144		* @param d the cookie's domain
145		* @param p the cookie's path
146		*/
147		CookieIdentifier(const QString &n, const QString &d, const QString &p);
148
149		/**
150		* Comparison operator
151		*
152		* Two cookies are equal if all their fields are equal
153		* @param other the identifier to compare this identifier to
154		* @return `true` if the two identifiers' name, domain and path are equal and `false` if at least one of them is different
155		*/
156		bool operator== (const CookieIdentifier &other) const {return name == other.name && domain == other.domain && path == other.path;}
157
158		/**
159		* @brief The name of the cookie
160		*
161		*/
162		QString name;
163		/**
164		* @brief The domain of the cookie
165		*
166		*/
167		QString domain;
168
169		/**
170		* @brief The path of the cookie
171		*
172		*/
173		QString path;
174
175		};
176
177		friend QDebug operator<<(QDebug, const CookieIdentifier &);
178
179		using CookieIdentifierList = QList<CookieIdentifier>;
180
181		/**
182		* @brief Checks whether a cookie with the given identifier is in the KCookieJar
183		*
184		* @note If the _id_'s domain doesn't start with a dot, a dot is prepended to it. This is because
185		* `KCookieJar` always wants a dot in front of the domain.
186		*
187		* @param id the identifiere of the cookie
188		* @param url the origin of the cookie
189		* @return `true` if a cookie with the given identifier is in the KCookieJar and `false` otherwise
190		*/
191		bool cookieInKCookieJar(const CookieIdentifier &id, const QUrl &url);
192
193		/**
194		* @brief The advice from `KCookieJar` for a URL
195		*
196		* @param url The URL to get the advice for
197		* @return The advice for _url_. It can be one of `"Accept"`, `"AcceptForSession"`, `"Reject"`, `"Ask"`, `"Dunno"` or an empty
198		* string if an error happens while contacting the `KCookieServer`
199		*/
200		QString askAdvice(const QUrl &url);
201
202		/**
203		* @brief Inserts all cookies contained in `KCookieJar` to the store
204		*
205		* @note this function should only be called by the constructor
206		* @note this function is asynchronous because it calls `QWebEngineCookieStore::setCookie`
207		*/
208		void loadKIOCookies();
209
210		/**
211		* @brief Finds all cookies stored in `KCookieJar`
212		* @return a list of the cookies in `KCookieJar`
213		*/
214		CookieList findKIOCookies();
215
216		/**
217		* @brief Enum describing the possible fields to pas to `KCookieServer::findCookies` using DBus.
218		*
219		* The values are the same as those of `CookieDetails` in `kio/src/kioslaves/http/kcookiejar/kcookieserver.cpp`
220		*/
221		enum class CookieDetails {domain=0, path=1, name=2, host=3, value=4, expirationDate=5, protocolVersion=6, secure=7};
222
223		/**
224		* @brief Parses the value returned by `KCookieServer::findCookies` for a single cookie
225		*
226		* This function assumes that all possible data for the cookie is availlable (that is, that the list returned by
227		* `KCookieServer::findCookies` contains an entry for each value in #CookieDetails)
228		*
229		* @param data: the data returned by `KCookieServer::findCookies`. It can contain data for more than one cookie, but only one will be parsed
230		* @param start: the position in the list where the data for the cookie starts.
231		* @return The cookie described by the data and its host
232		*/
233		static QNetworkCookie parseKIOCookie(const QStringList &data, int start);
234
	dfaureUnsubmitted Not Done 5 spaces? strange indentation dfaure: 5 spaces? strange indentation
235		/**
236		* @brief Function used to filter cookies
237		*
238		* In theory, this function should use the configuration chosen by the user in the Cookies KCM. However, this can't be done for several reasons:
239		* - this function doesn't have the cookies details availlable and they're needed for the "Ask" policy
240		* - this function doesn't know the URL of the cookie (even if `QWebEngineCookieStore::FilterRequest::origin` could be used as a substitute
241		* - if the policy is "Ask" and the question was asked here, it would be asked again when adding the cookie to `KCookieJar`.
242		* Because of these reasons, the only setting from the KCM which is applied here is whether to accept and reject cross domain cookies. Other settings
243		* from the KCM will be enforced by the addCookies().
244		*
245		* @param req the request to filter
246		* @return ``false` for third party cookies if the user chose to block them in the KCM and `true` otherwise
247		* @internal Besides filtering cookie requests, this function also stores the `origin` member of request in the #m_lastRequestOrigin.
248		* @endinternal
249		* @sa addCookie()
250		*/
251		bool filterCookie(const QWebEngineCookieStore::FilterRequest &req);
252
253		/**
254		* @brief Adds a dot in front of a domain if it's not already there
255		*
256		* @param dom the domain
257		* @return `dom` if it already starts with a dot and `dom` preceeded by a dot otherwise
258		*
259		* @internal
260		* This function is needed because KCookieJar prepends a dot to all domains not starting with one (according
261		* to `KCookieJar::makeCookies` in `kcookiejar.cpp`)
262		*/
263		static inline QString prependDotToDomain(const QString &dom) {return dom.startsWith(".") ? dom : "." + dom;}
264
265		QUrl constructUrlForCookie(const QNetworkCookie &cookie) const;
266
267		/**
268		* @brief The `QWebEngineCookieStore` to synchronize KIO with
269		*/
270		QWebEngineCookieStore* m_cookieStore;
271
272		/**
273		* @brief The DBus interface used to connect to KCookieServer
274		*/
275		QDBusInterface m_cookieServer;
276
277		/**
278		* @brief The fields to pass to `KCookieStore::findCookies` via DBus
279		*/
280		static const QVariant s_findCookieFields;
281
282		/**
	dfaureUnsubmitted Not Done CookieIdentifier is bigger than a pointer, so a QVector would be much more efficient. dfaure: CookieIdentifier is bigger than a pointer, so a QVector would be much more efficient.
283		* @brief Overload of `qHash` for a #CookieIdentifier
284		*
285		* @param id: the other identifier
286		* @param seed: the seed
287		* @return The hash value of the identifier
288		*/
289		friend uint qHash(const CookieIdentifier &id, uint seed){return qHash(QStringList{id.name, id.domain, id.path}, seed);};
290
291		/**
292		* @brief A list of cookies which were added to to the `QWebEngineCookieStore` but were rejected by KCookieJar and must
293		* be removed from the store
294		*
295		* When cookieRemoved() is called with one of those cookies, the cookie is removed from this list and no attempt is made to remove
296		* the cookie from `KCookieJar` (because it's not there)
297		*/
298		QVector<CookieIdentifier> m_pendingRejectedCookies;
299
300		/**
301		* @brief The IDs of all the windows which have session cookies
302		*/
303		QSet<qlonglong> m_windowsWithSessionCookies;
304
305		/**
306		* @brief A list of cookies loaded from KCookieServer when this instance is created
307		*/
308		CookieList m_cookiesLoadedFromKCookieServer;
309
310		};
311
312		/**
313		* @brief Overload of operator `<<` to allow a WebEnginePartCookieJar::CookieIdentifier to be written to a `QDebug`
314		*
315		* @param deb: the debug object
316		* @param id: the identifier to write
317		* @return the debug object
318		*/
319		QDebug operator<<(QDebug deb, const WebEnginePartCookieJar::CookieIdentifier &id);
320
321		#endif // WEBENGINEPARTCOOKIEJAR_H