1 | // Copyright (C) 2016 The Qt Company Ltd. |
2 | // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only |
3 | |
4 | #ifndef QHTTPTHREADDELEGATE_H |
5 | #define QHTTPTHREADDELEGATE_H |
6 | |
7 | |
8 | // |
9 | // W A R N I N G |
10 | // ------------- |
11 | // |
12 | // This file is not part of the Qt API. It exists for the convenience |
13 | // of the Network Access API. This header file may change from |
14 | // version to version without notice, or even be removed. |
15 | // |
16 | // We mean it. |
17 | // |
18 | |
19 | #include <QtNetwork/private/qtnetworkglobal_p.h> |
20 | #include <QObject> |
21 | #include <QThreadStorage> |
22 | #include <QNetworkProxy> |
23 | #include <QSslConfiguration> |
24 | #include <QSslError> |
25 | #include <QList> |
26 | #include <QNetworkReply> |
27 | #include "qhttpnetworkrequest_p.h" |
28 | #include "qhttpnetworkconnection_p.h" |
29 | #include "qhttp1configuration.h" |
30 | #include "qhttp2configuration.h" |
31 | #include <QSharedPointer> |
32 | #include <QScopedPointer> |
33 | #include "private/qnoncontiguousbytedevice_p.h" |
34 | #include "qnetworkaccessauthenticationmanager_p.h" |
35 | #include <QtNetwork/private/http2protocol_p.h> |
36 | #include <QtNetwork/qhttpheaders.h> |
37 | |
38 | QT_REQUIRE_CONFIG(http); |
39 | |
40 | QT_BEGIN_NAMESPACE |
41 | |
42 | class QAuthenticator; |
43 | class QHttpNetworkReply; |
44 | class QEventLoop; |
45 | class QNetworkAccessCache; |
46 | class QNetworkAccessCachedHttpConnection; |
47 | |
48 | class QHttpThreadDelegate : public QObject |
49 | { |
50 | Q_OBJECT |
51 | public: |
52 | explicit QHttpThreadDelegate(QObject *parent = nullptr); |
53 | |
54 | ~QHttpThreadDelegate(); |
55 | |
56 | // incoming |
57 | bool ssl; |
58 | #ifndef QT_NO_SSL |
59 | QScopedPointer<QSslConfiguration> incomingSslConfiguration; |
60 | #endif |
61 | QHttpNetworkRequest httpRequest; |
62 | qint64 downloadBufferMaximumSize; |
63 | qint64 readBufferMaxSize; |
64 | qint64 bytesEmitted; |
65 | // From backend, modified by us for signal compression |
66 | std::shared_ptr<QAtomicInt> pendingDownloadData; |
67 | std::shared_ptr<QAtomicInt> pendingDownloadProgress; |
68 | #ifndef QT_NO_NETWORKPROXY |
69 | QNetworkProxy cacheProxy; |
70 | QNetworkProxy transparentProxy; |
71 | #endif |
72 | std::shared_ptr<QNetworkAccessAuthenticationManager> authenticationManager; |
73 | bool synchronous; |
74 | qint64 connectionCacheExpiryTimeoutSeconds; |
75 | |
76 | // outgoing, Retrieved in the synchronous HTTP case |
77 | QByteArray synchronousDownloadData; |
78 | QHttpHeaders ; |
79 | int incomingStatusCode; |
80 | QString incomingReasonPhrase; |
81 | bool isPipeliningUsed; |
82 | bool isHttp2Used; |
83 | bool isCompressed = false; |
84 | qint64 incomingContentLength; |
85 | qint64 removedContentLength; |
86 | QNetworkReply::NetworkError incomingErrorCode; |
87 | QString incomingErrorDetail; |
88 | QHttp1Configuration http1Parameters; |
89 | QHttp2Configuration http2Parameters; |
90 | |
91 | protected: |
92 | // The zerocopy download buffer, if used: |
93 | QSharedPointer<char> downloadBuffer; |
94 | // The QHttpNetworkConnection that is used |
95 | QNetworkAccessCachedHttpConnection *httpConnection; |
96 | QByteArray cacheKey; |
97 | QHttpNetworkReply *httpReply; |
98 | |
99 | // Used for implementing the synchronous HTTP, see startRequestSynchronously() |
100 | QEventLoop *synchronousRequestLoop; |
101 | |
102 | signals: |
103 | void authenticationRequired(const QHttpNetworkRequest &request, QAuthenticator *); |
104 | #ifndef QT_NO_NETWORKPROXY |
105 | void proxyAuthenticationRequired(const QNetworkProxy &, QAuthenticator *); |
106 | #endif |
107 | #ifndef QT_NO_SSL |
108 | void encrypted(); |
109 | void sslErrors(const QList<QSslError> &, bool *, QList<QSslError> *); |
110 | void sslConfigurationChanged(const QSslConfiguration &); |
111 | void preSharedKeyAuthenticationRequired(QSslPreSharedKeyAuthenticator *); |
112 | #endif |
113 | void socketStartedConnecting(); |
114 | void requestSent(); |
115 | void (const QHttpHeaders &, int, const QString &, bool, |
116 | QSharedPointer<char>, qint64, qint64, bool, bool); |
117 | void downloadProgress(qint64, qint64); |
118 | void downloadData(const QByteArray &); |
119 | void error(QNetworkReply::NetworkError, const QString &); |
120 | void downloadFinished(); |
121 | void redirected(const QUrl &url, int httpStatus, int maxRedirectsRemainig); |
122 | |
123 | public slots: |
124 | // This are called via QueuedConnection from user thread |
125 | void startRequest(); |
126 | void abortRequest(); |
127 | void readBufferSizeChanged(qint64 size); |
128 | void readBufferFreed(qint64 size); |
129 | |
130 | // This is called with a BlockingQueuedConnection from user thread |
131 | void startRequestSynchronously(); |
132 | protected slots: |
133 | // From QHttp* |
134 | void readyReadSlot(); |
135 | void finishedSlot(); |
136 | void finishedWithErrorSlot(QNetworkReply::NetworkError errorCode, const QString &detail = QString()); |
137 | void synchronousFinishedSlot(); |
138 | void synchronousFinishedWithErrorSlot(QNetworkReply::NetworkError errorCode, const QString &detail = QString()); |
139 | void (); |
140 | void (); |
141 | void dataReadProgressSlot(qint64 done, qint64 total); |
142 | void cacheCredentialsSlot(const QHttpNetworkRequest &request, QAuthenticator *authenticator); |
143 | #ifndef QT_NO_SSL |
144 | void encryptedSlot(); |
145 | void (const QList<QSslError> &errors); |
146 | void preSharedKeyAuthenticationRequiredSlot(QSslPreSharedKeyAuthenticator *authenticator); |
147 | #endif |
148 | |
149 | void synchronousAuthenticationRequiredSlot(const QHttpNetworkRequest &request, QAuthenticator *); |
150 | #ifndef QT_NO_NETWORKPROXY |
151 | void synchronousProxyAuthenticationRequiredSlot(const QNetworkProxy &, QAuthenticator *); |
152 | #endif |
153 | |
154 | protected: |
155 | // Cache for all the QHttpNetworkConnection objects. |
156 | // This is per thread. |
157 | static QThreadStorage<QNetworkAccessCache *> connections; |
158 | |
159 | }; |
160 | |
161 | // This QNonContiguousByteDevice is connected to the QNetworkAccessHttpBackend |
162 | // and represents the PUT/POST data. |
163 | class QNonContiguousByteDeviceThreadForwardImpl : public QNonContiguousByteDevice |
164 | { |
165 | Q_OBJECT |
166 | protected: |
167 | bool wantDataPending = false; |
168 | qint64 m_amount = 0; |
169 | char *m_data = nullptr; |
170 | QByteArray m_dataArray; |
171 | bool m_atEnd = false; |
172 | qint64 m_size = 0; |
173 | qint64 m_pos = 0; // to match calls of haveDataSlot with the expected position |
174 | public: |
175 | QNonContiguousByteDeviceThreadForwardImpl(bool aE, qint64 s) |
176 | : QNonContiguousByteDevice(), |
177 | m_atEnd(aE), |
178 | m_size(s) |
179 | { |
180 | } |
181 | |
182 | ~QNonContiguousByteDeviceThreadForwardImpl() |
183 | { |
184 | } |
185 | |
186 | qint64 pos() const override |
187 | { |
188 | return m_pos; |
189 | } |
190 | |
191 | const char* readPointer(qint64 maximumLength, qint64 &len) override |
192 | { |
193 | if (m_amount > 0) { |
194 | len = m_amount; |
195 | return m_data; |
196 | } |
197 | |
198 | if (m_atEnd) { |
199 | len = -1; |
200 | } else if (!wantDataPending) { |
201 | len = 0; |
202 | wantDataPending = true; |
203 | emit wantData(maximumLength); |
204 | } else { |
205 | // Do nothing, we already sent a wantData signal and wait for results |
206 | len = 0; |
207 | } |
208 | return nullptr; |
209 | } |
210 | |
211 | bool advanceReadPointer(qint64 a) override |
212 | { |
213 | if (m_data == nullptr) |
214 | return false; |
215 | |
216 | m_amount -= a; |
217 | m_data += a; |
218 | m_pos += a; |
219 | |
220 | // To main thread to inform about our state. The m_pos will be sent as a sanity check. |
221 | emit processedData(pos: m_pos, amount: a); |
222 | |
223 | return true; |
224 | } |
225 | |
226 | bool atEnd() const override |
227 | { |
228 | if (m_amount > 0) |
229 | return false; |
230 | else |
231 | return m_atEnd; |
232 | } |
233 | |
234 | bool reset() override |
235 | { |
236 | m_amount = 0; |
237 | m_data = nullptr; |
238 | m_dataArray.clear(); |
239 | |
240 | if (wantDataPending) { |
241 | // had requested the user thread to send some data (only 1 in-flight at any moment) |
242 | wantDataPending = false; |
243 | } |
244 | |
245 | // Communicate as BlockingQueuedConnection |
246 | bool b = false; |
247 | emit resetData(b: &b); |
248 | if (b) { |
249 | // the reset succeeded, we're at pos 0 again |
250 | m_pos = 0; |
251 | m_atEnd = false; |
252 | // the HTTP code will anyway abort the request if !b. |
253 | } |
254 | return b; |
255 | } |
256 | |
257 | qint64 size() const override |
258 | { |
259 | return m_size; |
260 | } |
261 | |
262 | public slots: |
263 | // From user thread: |
264 | void haveDataSlot(qint64 pos, const QByteArray &dataArray, bool dataAtEnd, qint64 dataSize) |
265 | { |
266 | if (pos != m_pos) { |
267 | // Sometimes when re-sending a request in the qhttpnetwork* layer there is a pending haveData from the |
268 | // user thread on the way to us. We need to ignore it since it is the data for the wrong(later) chunk. |
269 | return; |
270 | } |
271 | wantDataPending = false; |
272 | |
273 | m_dataArray = dataArray; |
274 | m_data = const_cast<char*>(m_dataArray.constData()); |
275 | m_amount = dataArray.size(); |
276 | |
277 | m_atEnd = dataAtEnd; |
278 | m_size = dataSize; |
279 | |
280 | // This will tell the HTTP code (QHttpNetworkConnectionChannel) that we have data available now |
281 | emit readyRead(); |
282 | } |
283 | |
284 | signals: |
285 | // void readyRead(); in parent class |
286 | // void readProgress(qint64 current, qint64 total); happens in the main thread with the real bytedevice |
287 | |
288 | // to main thread: |
289 | void wantData(qint64); |
290 | void processedData(qint64 pos, qint64 amount); |
291 | void resetData(bool *b); |
292 | }; |
293 | |
294 | QT_END_NAMESPACE |
295 | |
296 | #endif // QHTTPTHREADDELEGATE_H |
297 | |