1 | // Copyright (C) 2022 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 | #include "qnetworkrequest.h" |
5 | #include "qnetworkrequest_p.h" |
6 | #include "qplatformdefs.h" |
7 | #include "qnetworkcookie.h" |
8 | #include "qsslconfiguration.h" |
9 | #include "qhttpheadershelper_p.h" |
10 | #if QT_CONFIG(http) |
11 | #include "qhttp1configuration.h" |
12 | #include "qhttp2configuration.h" |
13 | #include "private/http2protocol_p.h" |
14 | #endif |
15 | |
16 | #include "QtCore/qdatetime.h" |
17 | #include "QtCore/qlocale.h" |
18 | #include "QtCore/qshareddata.h" |
19 | #include "QtCore/qtimezone.h" |
20 | #include "QtCore/private/qduplicatetracker_p.h" |
21 | #include "QtCore/private/qtools_p.h" |
22 | |
23 | #include <ctype.h> |
24 | #if QT_CONFIG(datestring) |
25 | # include <stdio.h> |
26 | #endif |
27 | |
28 | #include <algorithm> |
29 | #include <q20algorithm.h> |
30 | |
31 | QT_BEGIN_NAMESPACE |
32 | |
33 | using namespace Qt::StringLiterals; |
34 | using namespace std::chrono_literals; |
35 | |
36 | constexpr std::chrono::milliseconds QNetworkRequest::DefaultTransferTimeout; |
37 | |
38 | QT_IMPL_METATYPE_EXTERN(QNetworkRequest) |
39 | QT_IMPL_METATYPE_EXTERN_TAGGED(QNetworkRequest::RedirectPolicy, QNetworkRequest__RedirectPolicy) |
40 | |
41 | /*! |
42 | \class QNetworkRequest |
43 | \since 4.4 |
44 | \ingroup network |
45 | \ingroup shared |
46 | \inmodule QtNetwork |
47 | |
48 | \brief The QNetworkRequest class holds a request to be sent with QNetworkAccessManager. |
49 | |
50 | QNetworkRequest is part of the Network Access API and is the class |
51 | holding the information necessary to send a request over the |
52 | network. It contains a URL and some ancillary information that can |
53 | be used to modify the request. |
54 | |
55 | \sa QNetworkReply, QNetworkAccessManager |
56 | */ |
57 | |
58 | /*! |
59 | \enum QNetworkRequest::KnownHeaders |
60 | |
61 | List of known header types that QNetworkRequest parses. Each known |
62 | header is also represented in raw form with its full HTTP name. |
63 | |
64 | \value ContentDispositionHeader Corresponds to the HTTP |
65 | Content-Disposition header and contains a string containing the |
66 | disposition type (for instance, attachment) and a parameter (for |
67 | instance, filename). |
68 | |
69 | \value ContentTypeHeader Corresponds to the HTTP Content-Type |
70 | header and contains a string containing the media (MIME) type and |
71 | any auxiliary data (for instance, charset). |
72 | |
73 | \value ContentLengthHeader Corresponds to the HTTP Content-Length |
74 | header and contains the length in bytes of the data transmitted. |
75 | |
76 | \value LocationHeader Corresponds to the HTTP Location |
77 | header and contains a URL representing the actual location of the |
78 | data, including the destination URL in case of redirections. |
79 | |
80 | \value LastModifiedHeader Corresponds to the HTTP Last-Modified |
81 | header and contains a QDateTime representing the last modification |
82 | date of the contents. |
83 | |
84 | \value IfModifiedSinceHeader Corresponds to the HTTP If-Modified-Since |
85 | header and contains a QDateTime. It is usually added to a |
86 | QNetworkRequest. The server shall send a 304 (Not Modified) response |
87 | if the resource has not changed since this time. |
88 | |
89 | \value ETagHeader Corresponds to the HTTP ETag |
90 | header and contains a QString representing the last modification |
91 | state of the contents. |
92 | |
93 | \value IfMatchHeader Corresponds to the HTTP If-Match |
94 | header and contains a QStringList. It is usually added to a |
95 | QNetworkRequest. The server shall send a 412 (Precondition Failed) |
96 | response if the resource does not match. |
97 | |
98 | \value IfNoneMatchHeader Corresponds to the HTTP If-None-Match |
99 | header and contains a QStringList. It is usually added to a |
100 | QNetworkRequest. The server shall send a 304 (Not Modified) response |
101 | if the resource does match. |
102 | |
103 | \value CookieHeader Corresponds to the HTTP Cookie header |
104 | and contains a QList<QNetworkCookie> representing the cookies to |
105 | be sent back to the server. |
106 | |
107 | \value SetCookieHeader Corresponds to the HTTP Set-Cookie |
108 | header and contains a QList<QNetworkCookie> representing the |
109 | cookies sent by the server to be stored locally. |
110 | |
111 | \value UserAgentHeader The User-Agent header sent by HTTP clients. |
112 | |
113 | \value ServerHeader The Server header received by HTTP clients. |
114 | |
115 | \omitvalue NumKnownHeaders |
116 | |
117 | \sa header(), setHeader(), rawHeader(), setRawHeader() |
118 | */ |
119 | |
120 | /*! |
121 | \enum QNetworkRequest::Attribute |
122 | \since 4.7 |
123 | |
124 | Attribute codes for the QNetworkRequest and QNetworkReply. |
125 | |
126 | Attributes are extra meta-data that are used to control the |
127 | behavior of the request and to pass further information from the |
128 | reply back to the application. Attributes are also extensible, |
129 | allowing custom implementations to pass custom values. |
130 | |
131 | The following table explains what the default attribute codes are, |
132 | the QVariant types associated, the default value if said attribute |
133 | is missing and whether it's used in requests or replies. |
134 | |
135 | \value HttpStatusCodeAttribute |
136 | Replies only, type: QMetaType::Int (no default) |
137 | Indicates the HTTP status code received from the HTTP server |
138 | (like 200, 304, 404, 401, etc.). If the connection was not |
139 | HTTP-based, this attribute will not be present. |
140 | |
141 | \value HttpReasonPhraseAttribute |
142 | Replies only, type: QMetaType::QByteArray (no default) |
143 | Indicates the HTTP reason phrase as received from the HTTP |
144 | server (like "Ok", "Found", "Not Found", "Access Denied", |
145 | etc.) This is the human-readable representation of the status |
146 | code (see above). If the connection was not HTTP-based, this |
147 | attribute will not be present. \e{Note:} The reason phrase is |
148 | not used when using HTTP/2. |
149 | |
150 | \value RedirectionTargetAttribute |
151 | Replies only, type: QMetaType::QUrl (no default) |
152 | If present, it indicates that the server is redirecting the |
153 | request to a different URL. The Network Access API does follow |
154 | redirections by default, unless |
155 | QNetworkRequest::ManualRedirectPolicy is used. Additionally, if |
156 | QNetworkRequest::UserVerifiedRedirectPolicy is used, then this |
157 | attribute will be set if the redirect was not followed. |
158 | The returned URL might be relative. Use QUrl::resolved() |
159 | to create an absolute URL out of it. |
160 | |
161 | \value ConnectionEncryptedAttribute |
162 | Replies only, type: QMetaType::Bool (default: false) |
163 | Indicates whether the data was obtained through an encrypted |
164 | (secure) connection. |
165 | |
166 | \value CacheLoadControlAttribute |
167 | Requests only, type: QMetaType::Int (default: QNetworkRequest::PreferNetwork) |
168 | Controls how the cache should be accessed. The possible values |
169 | are those of QNetworkRequest::CacheLoadControl. Note that the |
170 | default QNetworkAccessManager implementation does not support |
171 | caching. However, this attribute may be used by certain |
172 | backends to modify their requests (for example, for caching proxies). |
173 | |
174 | \value CacheSaveControlAttribute |
175 | Requests only, type: QMetaType::Bool (default: true) |
176 | Controls if the data obtained should be saved to cache for |
177 | future uses. If the value is false, the data obtained will not |
178 | be automatically cached. If true, data may be cached, provided |
179 | it is cacheable (what is cacheable depends on the protocol |
180 | being used). |
181 | |
182 | \value SourceIsFromCacheAttribute |
183 | Replies only, type: QMetaType::Bool (default: false) |
184 | Indicates whether the data was obtained from cache |
185 | or not. |
186 | |
187 | \value DoNotBufferUploadDataAttribute |
188 | Requests only, type: QMetaType::Bool (default: false) |
189 | Indicates whether the QNetworkAccessManager code is |
190 | allowed to buffer the upload data, e.g. when doing a HTTP POST. |
191 | When using this flag with sequential upload data, the ContentLengthHeader |
192 | header must be set. |
193 | |
194 | \value HttpPipeliningAllowedAttribute |
195 | Requests only, type: QMetaType::Bool (default: false) |
196 | Indicates whether the QNetworkAccessManager code is |
197 | allowed to use HTTP pipelining with this request. |
198 | |
199 | \value HttpPipeliningWasUsedAttribute |
200 | Replies only, type: QMetaType::Bool |
201 | Indicates whether the HTTP pipelining was used for receiving |
202 | this reply. |
203 | |
204 | \value CustomVerbAttribute |
205 | Requests only, type: QMetaType::QByteArray |
206 | Holds the value for the custom HTTP verb to send (destined for usage |
207 | of other verbs than GET, POST, PUT and DELETE). This verb is set |
208 | when calling QNetworkAccessManager::sendCustomRequest(). |
209 | |
210 | \value CookieLoadControlAttribute |
211 | Requests only, type: QMetaType::Int (default: QNetworkRequest::Automatic) |
212 | Indicates whether to send 'Cookie' headers in the request. |
213 | This attribute is set to false by Qt WebKit when creating a cross-origin |
214 | XMLHttpRequest where withCredentials has not been set explicitly to true by the |
215 | Javascript that created the request. |
216 | See \l{http://www.w3.org/TR/XMLHttpRequest2/#credentials-flag}{here} for more information. |
217 | (This value was introduced in 4.7.) |
218 | |
219 | \value CookieSaveControlAttribute |
220 | Requests only, type: QMetaType::Int (default: QNetworkRequest::Automatic) |
221 | Indicates whether to save 'Cookie' headers received from the server in reply |
222 | to the request. |
223 | This attribute is set to false by Qt WebKit when creating a cross-origin |
224 | XMLHttpRequest where withCredentials has not been set explicitly to true by the |
225 | Javascript that created the request. |
226 | See \l{http://www.w3.org/TR/XMLHttpRequest2/#credentials-flag} {here} for more information. |
227 | (This value was introduced in 4.7.) |
228 | |
229 | \value AuthenticationReuseAttribute |
230 | Requests only, type: QMetaType::Int (default: QNetworkRequest::Automatic) |
231 | Indicates whether to use cached authorization credentials in the request, |
232 | if available. If this is set to QNetworkRequest::Manual and the authentication |
233 | mechanism is 'Basic' or 'Digest', Qt will not send an 'Authorization' HTTP |
234 | header with any cached credentials it may have for the request's URL. |
235 | This attribute is set to QNetworkRequest::Manual by Qt WebKit when creating a cross-origin |
236 | XMLHttpRequest where withCredentials has not been set explicitly to true by the |
237 | Javascript that created the request. |
238 | See \l{http://www.w3.org/TR/XMLHttpRequest2/#credentials-flag} {here} for more information. |
239 | (This value was introduced in 4.7.) |
240 | |
241 | \omitvalue MaximumDownloadBufferSizeAttribute |
242 | |
243 | \omitvalue DownloadBufferAttribute |
244 | |
245 | \omitvalue SynchronousRequestAttribute |
246 | |
247 | \value BackgroundRequestAttribute |
248 | Type: QMetaType::Bool (default: false) |
249 | Indicates that this is a background transfer, rather than a user initiated |
250 | transfer. Depending on the platform, background transfers may be subject |
251 | to different policies. |
252 | |
253 | \value Http2AllowedAttribute |
254 | Requests only, type: QMetaType::Bool (default: true) |
255 | Indicates whether the QNetworkAccessManager code is |
256 | allowed to use HTTP/2 with this request. This applies |
257 | to SSL requests or 'cleartext' HTTP/2 if Http2CleartextAllowedAttribute |
258 | is set. |
259 | |
260 | \value Http2WasUsedAttribute |
261 | Replies only, type: QMetaType::Bool (default: false) |
262 | Indicates whether HTTP/2 was used for receiving this reply. |
263 | (This value was introduced in 5.9.) |
264 | |
265 | \value EmitAllUploadProgressSignalsAttribute |
266 | Requests only, type: QMetaType::Bool (default: false) |
267 | Indicates whether all upload signals should be emitted. |
268 | By default, the uploadProgress signal is emitted only |
269 | in 100 millisecond intervals. |
270 | (This value was introduced in 5.5.) |
271 | |
272 | \value OriginalContentLengthAttribute |
273 | Replies only, type QMetaType::Int |
274 | Holds the original content-length attribute before being invalidated and |
275 | removed from the header when the data is compressed and the request was |
276 | marked to be decompressed automatically. |
277 | (This value was introduced in 5.9.) |
278 | |
279 | \value RedirectPolicyAttribute |
280 | Requests only, type: QMetaType::Int, should be one of the |
281 | QNetworkRequest::RedirectPolicy values |
282 | (default: NoLessSafeRedirectPolicy). |
283 | (This value was introduced in 5.9.) |
284 | |
285 | \value Http2DirectAttribute |
286 | Requests only, type: QMetaType::Bool (default: false) |
287 | If set, this attribute will force QNetworkAccessManager to use |
288 | HTTP/2 protocol without initial HTTP/2 protocol negotiation. |
289 | Use of this attribute implies prior knowledge that a particular |
290 | server supports HTTP/2. The attribute works with SSL or with 'cleartext' |
291 | HTTP/2 if Http2CleartextAllowedAttribute is set. |
292 | If a server turns out to not support HTTP/2, when HTTP/2 direct |
293 | was specified, QNetworkAccessManager gives up, without attempting to |
294 | fall back to HTTP/1.1. If both Http2AllowedAttribute and |
295 | Http2DirectAttribute are set, Http2DirectAttribute takes priority. |
296 | (This value was introduced in 5.11.) |
297 | |
298 | \omitvalue ResourceTypeAttribute |
299 | |
300 | \value AutoDeleteReplyOnFinishAttribute |
301 | Requests only, type: QMetaType::Bool (default: false) |
302 | If set, this attribute will make QNetworkAccessManager delete |
303 | the QNetworkReply after having emitted "finished". |
304 | (This value was introduced in 5.14.) |
305 | |
306 | \value ConnectionCacheExpiryTimeoutSecondsAttribute |
307 | Requests only, type: QMetaType::Int |
308 | To set when the TCP connections to a server (HTTP1 and HTTP2) should |
309 | be closed after the last pending request had been processed. |
310 | (This value was introduced in 6.3.) |
311 | |
312 | \value Http2CleartextAllowedAttribute |
313 | Requests only, type: QMetaType::Bool (default: false) |
314 | If set, this attribute will tell QNetworkAccessManager to attempt |
315 | an upgrade to HTTP/2 over cleartext (also known as h2c). |
316 | Until Qt 7 the default value for this attribute can be overridden |
317 | to true by setting the QT_NETWORK_H2C_ALLOWED environment variable. |
318 | This attribute is ignored if the Http2AllowedAttribute is not set. |
319 | (This value was introduced in 6.3.) |
320 | |
321 | \value UseCredentialsAttribute |
322 | Requests only, type: QMetaType::Bool (default: false) |
323 | Indicates if the underlying XMLHttpRequest cross-site Access-Control |
324 | requests should be made using credentials. Has no effect on |
325 | same-origin requests. This only affects the WebAssembly platform. |
326 | (This value was introduced in 6.5.) |
327 | |
328 | \value FullLocalServerNameAttribute |
329 | Requests only, type: QMetaType::String |
330 | Holds the full local server name to be used for the underlying |
331 | QLocalSocket. This attribute is used by the QNetworkAccessManager |
332 | to connect to a specific local server, when QLocalSocket's behavior for |
333 | a simple name isn't enough. The URL in the QNetworkRequest must still |
334 | use unix+http: or local+http: scheme. And the hostname in the URL will |
335 | be used for the Host header in the HTTP request. |
336 | (This value was introduced in 6.8.) |
337 | |
338 | \value User |
339 | Special type. Additional information can be passed in |
340 | QVariants with types ranging from User to UserMax. The default |
341 | implementation of Network Access will ignore any request |
342 | attributes in this range and it will not produce any |
343 | attributes in this range in replies. The range is reserved for |
344 | extensions of QNetworkAccessManager. |
345 | |
346 | \value UserMax |
347 | Special type. See User. |
348 | */ |
349 | |
350 | /*! |
351 | \enum QNetworkRequest::CacheLoadControl |
352 | |
353 | Controls the caching mechanism of QNetworkAccessManager. |
354 | |
355 | \value AlwaysNetwork always load from network and do not |
356 | check if the cache has a valid entry (similar to the |
357 | "Reload" feature in browsers); in addition, force intermediate |
358 | caches to re-validate. |
359 | |
360 | \value PreferNetwork default value; load from the network |
361 | if the cached entry is older than the network entry. This will never |
362 | return stale data from the cache, but revalidate resources that |
363 | have become stale. |
364 | |
365 | \value PreferCache load from cache if available, |
366 | otherwise load from network. Note that this can return possibly |
367 | stale (but not expired) items from cache. |
368 | |
369 | \value AlwaysCache only load from cache, indicating error |
370 | if the item was not cached (i.e., off-line mode) |
371 | */ |
372 | |
373 | /*! |
374 | \enum QNetworkRequest::LoadControl |
375 | \since 4.7 |
376 | |
377 | Indicates if an aspect of the request's loading mechanism has been |
378 | manually overridden, e.g. by Qt WebKit. |
379 | |
380 | \value Automatic default value: indicates default behaviour. |
381 | |
382 | \value Manual indicates behaviour has been manually overridden. |
383 | */ |
384 | |
385 | /*! |
386 | \enum QNetworkRequest::RedirectPolicy |
387 | \since 5.9 |
388 | |
389 | Indicates whether the Network Access API should automatically follow a |
390 | HTTP redirect response or not. |
391 | |
392 | \value ManualRedirectPolicy Not following any redirects. |
393 | |
394 | \value NoLessSafeRedirectPolicy Default value: Only "http"->"http", |
395 | "http" -> "https" or "https" -> "https" redirects |
396 | are allowed. |
397 | |
398 | \value SameOriginRedirectPolicy Require the same protocol, host and port. |
399 | Note, http://example.com and http://example.com:80 |
400 | will fail with this policy (implicit/explicit ports |
401 | are considered to be a mismatch). |
402 | |
403 | \value UserVerifiedRedirectPolicy Client decides whether to follow each |
404 | redirect by handling the redirected() |
405 | signal, emitting redirectAllowed() on |
406 | the QNetworkReply object to allow |
407 | the redirect or aborting/finishing it to |
408 | reject the redirect. This can be used, |
409 | for example, to ask the user whether to |
410 | accept the redirect, or to decide |
411 | based on some app-specific configuration. |
412 | |
413 | \note When Qt handles redirects it will, for legacy and compatibility |
414 | reasons, issue the redirected request using GET when the server returns |
415 | a 301 or 302 response, regardless of the original method used, unless it was |
416 | HEAD. |
417 | */ |
418 | |
419 | /*! |
420 | \enum QNetworkRequest::TransferTimeoutConstant |
421 | \since 5.15 |
422 | |
423 | A constant that can be used for enabling transfer |
424 | timeouts with a preset value. |
425 | |
426 | \value DefaultTransferTimeoutConstant The transfer timeout in milliseconds. |
427 | Used if setTimeout() is called |
428 | without an argument. |
429 | |
430 | \sa QNetworkRequest::DefaultTransferTimeout |
431 | */ |
432 | |
433 | /*! |
434 | \variable QNetworkRequest::DefaultTransferTimeout |
435 | |
436 | The transfer timeout with \l {QNetworkRequest::TransferTimeoutConstant} |
437 | milliseconds. Used if setTransferTimeout() is called without an |
438 | argument. |
439 | */ |
440 | |
441 | class QNetworkRequestPrivate: public QSharedData, public QNetworkHeadersPrivate |
442 | { |
443 | public: |
444 | static const int maxRedirectCount = 50; |
445 | inline QNetworkRequestPrivate() |
446 | : priority(QNetworkRequest::NormalPriority) |
447 | #ifndef QT_NO_SSL |
448 | , sslConfiguration(nullptr) |
449 | #endif |
450 | , maxRedirectsAllowed(maxRedirectCount) |
451 | { qRegisterMetaType<QNetworkRequest>(); } |
452 | ~QNetworkRequestPrivate() |
453 | { |
454 | #ifndef QT_NO_SSL |
455 | delete sslConfiguration; |
456 | #endif |
457 | } |
458 | |
459 | |
460 | QNetworkRequestPrivate(const QNetworkRequestPrivate &other) |
461 | : QSharedData(other), QNetworkHeadersPrivate(other) |
462 | { |
463 | url = other.url; |
464 | priority = other.priority; |
465 | maxRedirectsAllowed = other.maxRedirectsAllowed; |
466 | #ifndef QT_NO_SSL |
467 | sslConfiguration = nullptr; |
468 | if (other.sslConfiguration) |
469 | sslConfiguration = new QSslConfiguration(*other.sslConfiguration); |
470 | #endif |
471 | peerVerifyName = other.peerVerifyName; |
472 | #if QT_CONFIG(http) |
473 | h1Configuration = other.h1Configuration; |
474 | h2Configuration = other.h2Configuration; |
475 | decompressedSafetyCheckThreshold = other.decompressedSafetyCheckThreshold; |
476 | #endif |
477 | transferTimeout = other.transferTimeout; |
478 | } |
479 | |
480 | inline bool operator==(const QNetworkRequestPrivate &other) const |
481 | { |
482 | return url == other.url && |
483 | priority == other.priority && |
484 | attributes == other.attributes && |
485 | maxRedirectsAllowed == other.maxRedirectsAllowed && |
486 | peerVerifyName == other.peerVerifyName |
487 | #if QT_CONFIG(http) |
488 | && h1Configuration == other.h1Configuration |
489 | && h2Configuration == other.h2Configuration |
490 | && decompressedSafetyCheckThreshold == other.decompressedSafetyCheckThreshold |
491 | #endif |
492 | && transferTimeout == other.transferTimeout |
493 | && QHttpHeadersHelper::compareStrict(left: httpHeaders, right: other.httpHeaders) |
494 | ; |
495 | // don't compare cookedHeaders |
496 | } |
497 | |
498 | QUrl url; |
499 | QNetworkRequest::Priority priority; |
500 | #ifndef QT_NO_SSL |
501 | mutable QSslConfiguration *sslConfiguration; |
502 | #endif |
503 | int maxRedirectsAllowed; |
504 | QString peerVerifyName; |
505 | #if QT_CONFIG(http) |
506 | QHttp1Configuration h1Configuration; |
507 | QHttp2Configuration h2Configuration; |
508 | qint64 decompressedSafetyCheckThreshold = 10ll * 1024ll * 1024ll; |
509 | #endif |
510 | std::chrono::milliseconds transferTimeout = 0ms; |
511 | }; |
512 | |
513 | /*! |
514 | Constructs a QNetworkRequest object with no URL to be requested. |
515 | Use setUrl() to set one. |
516 | |
517 | \sa url(), setUrl() |
518 | */ |
519 | QNetworkRequest::QNetworkRequest() |
520 | : d(new QNetworkRequestPrivate) |
521 | { |
522 | #if QT_CONFIG(http) |
523 | // Initial values proposed by RFC 7540 are quite draconian, but we |
524 | // know about servers configured with this value as maximum possible, |
525 | // rejecting our SETTINGS frame and sending us a GOAWAY frame with the |
526 | // flow control error set. If this causes a problem - the app should |
527 | // set a proper configuration. We'll use our defaults, as documented. |
528 | d->h2Configuration.setStreamReceiveWindowSize(Http2::qtDefaultStreamReceiveWindowSize); |
529 | d->h2Configuration.setSessionReceiveWindowSize(Http2::maxSessionReceiveWindowSize); |
530 | d->h2Configuration.setServerPushEnabled(false); |
531 | #endif // QT_CONFIG(http) |
532 | } |
533 | |
534 | /*! |
535 | Constructs a QNetworkRequest object with \a url as the URL to be |
536 | requested. |
537 | |
538 | \sa url(), setUrl() |
539 | */ |
540 | QNetworkRequest::QNetworkRequest(const QUrl &url) |
541 | : QNetworkRequest() |
542 | { |
543 | d->url = url; |
544 | } |
545 | |
546 | /*! |
547 | Creates a copy of \a other. |
548 | */ |
549 | QNetworkRequest::QNetworkRequest(const QNetworkRequest &other) |
550 | : d(other.d) |
551 | { |
552 | } |
553 | |
554 | /*! |
555 | Disposes of the QNetworkRequest object. |
556 | */ |
557 | QNetworkRequest::~QNetworkRequest() |
558 | { |
559 | // QSharedDataPointer auto deletes |
560 | d = nullptr; |
561 | } |
562 | |
563 | /*! |
564 | Returns \c true if this object is the same as \a other (i.e., if they |
565 | have the same URL, same headers and same meta-data settings). |
566 | |
567 | \sa operator!=() |
568 | */ |
569 | bool QNetworkRequest::operator==(const QNetworkRequest &other) const |
570 | { |
571 | return d == other.d || *d == *other.d; |
572 | } |
573 | |
574 | /*! |
575 | \fn bool QNetworkRequest::operator!=(const QNetworkRequest &other) const |
576 | |
577 | Returns \c false if this object is not the same as \a other. |
578 | |
579 | \sa operator==() |
580 | */ |
581 | |
582 | /*! |
583 | Creates a copy of \a other |
584 | */ |
585 | QNetworkRequest &QNetworkRequest::operator=(const QNetworkRequest &other) |
586 | { |
587 | d = other.d; |
588 | return *this; |
589 | } |
590 | |
591 | /*! |
592 | \fn void QNetworkRequest::swap(QNetworkRequest &other) |
593 | \since 5.0 |
594 | \memberswap{network request} |
595 | */ |
596 | |
597 | /*! |
598 | Returns the URL this network request is referring to. |
599 | |
600 | \sa setUrl() |
601 | */ |
602 | QUrl QNetworkRequest::url() const |
603 | { |
604 | return d->url; |
605 | } |
606 | |
607 | /*! |
608 | Sets the URL this network request is referring to be \a url. |
609 | |
610 | \sa url() |
611 | */ |
612 | void QNetworkRequest::setUrl(const QUrl &url) |
613 | { |
614 | d->url = url; |
615 | } |
616 | |
617 | /*! |
618 | \since 6.8 |
619 | |
620 | Returns headers that are set in this network request. |
621 | |
622 | \sa setHeaders() |
623 | */ |
624 | QHttpHeaders QNetworkRequest::headers() const |
625 | { |
626 | return d->headers(); |
627 | } |
628 | |
629 | /*! |
630 | \since 6.8 |
631 | |
632 | Sets \a newHeaders as headers in this network request, overriding |
633 | any previously set headers. |
634 | |
635 | If some headers correspond to the known headers, the values will |
636 | be parsed and the corresponding parsed form will also be set. |
637 | |
638 | \sa headers(), KnownHeaders |
639 | */ |
640 | void QNetworkRequest::setHeaders(QHttpHeaders &&newHeaders) |
641 | { |
642 | d->setHeaders(std::move(newHeaders)); |
643 | } |
644 | |
645 | /*! |
646 | \overload |
647 | \since 6.8 |
648 | */ |
649 | void QNetworkRequest::setHeaders(const QHttpHeaders &newHeaders) |
650 | { |
651 | d->setHeaders(newHeaders); |
652 | } |
653 | |
654 | /*! |
655 | Returns the value of the known network header \a header if it is |
656 | present in this request. If it is not present, returns QVariant() |
657 | (i.e., an invalid variant). |
658 | |
659 | \sa KnownHeaders, rawHeader(), setHeader() |
660 | */ |
661 | QVariant QNetworkRequest::header(KnownHeaders header) const |
662 | { |
663 | return d->cookedHeaders.value(key: header); |
664 | } |
665 | |
666 | /*! |
667 | Sets the value of the known header \a header to be \a value, |
668 | overriding any previously set headers. This operation also sets |
669 | the equivalent raw HTTP header. |
670 | |
671 | \sa KnownHeaders, setRawHeader(), header() |
672 | */ |
673 | void QNetworkRequest::setHeader(KnownHeaders header, const QVariant &value) |
674 | { |
675 | d->setCookedHeader(header, value); |
676 | } |
677 | |
678 | /*! |
679 | Returns \c true if the raw header \a headerName is present in this |
680 | network request. |
681 | |
682 | \sa rawHeader(), setRawHeader() |
683 | \note In Qt versions prior to 6.7, this function took QByteArray only. |
684 | */ |
685 | bool QNetworkRequest::hasRawHeader(QAnyStringView headerName) const |
686 | { |
687 | return d->headers().contains(name: headerName); |
688 | } |
689 | |
690 | /*! |
691 | Returns the raw form of header \a headerName. If no such header is |
692 | present, an empty QByteArray is returned, which may be |
693 | indistinguishable from a header that is present but has no content |
694 | (use hasRawHeader() to find out if the header exists or not). |
695 | |
696 | Raw headers can be set with setRawHeader() or with setHeader(). |
697 | |
698 | \sa header(), setRawHeader() |
699 | \note In Qt versions prior to 6.7, this function took QByteArray only. |
700 | */ |
701 | QByteArray QNetworkRequest::rawHeader(QAnyStringView headerName) const |
702 | { |
703 | return d->rawHeader(headerName); |
704 | } |
705 | |
706 | /*! |
707 | Returns a list of all raw headers that are set in this network |
708 | request. The list is in the order that the headers were set. |
709 | |
710 | \sa hasRawHeader(), rawHeader() |
711 | */ |
712 | QList<QByteArray> QNetworkRequest::rawHeaderList() const |
713 | { |
714 | return d->rawHeadersKeys(); |
715 | } |
716 | |
717 | /*! |
718 | Sets the header \a headerName to be of value \a headerValue. If \a |
719 | headerName corresponds to a known header (see |
720 | QNetworkRequest::KnownHeaders), the raw format will be parsed and |
721 | the corresponding "cooked" header will be set as well. |
722 | |
723 | For example: |
724 | \snippet code/src_network_access_qnetworkrequest.cpp 0 |
725 | |
726 | will also set the known header LastModifiedHeader to be the |
727 | QDateTime object of the parsed date. |
728 | |
729 | \note Setting the same header twice overrides the previous |
730 | setting. To accomplish the behaviour of multiple HTTP headers of |
731 | the same name, you should concatenate the two values, separating |
732 | them with a comma (",") and set one single raw header. |
733 | |
734 | \note Since Qt 6.8, the header field names are normalized |
735 | by converting them to lowercase. |
736 | |
737 | \sa KnownHeaders, setHeader(), hasRawHeader(), rawHeader() |
738 | */ |
739 | void QNetworkRequest::setRawHeader(const QByteArray &headerName, const QByteArray &headerValue) |
740 | { |
741 | d->setRawHeader(key: headerName, value: headerValue); |
742 | } |
743 | |
744 | /*! |
745 | Returns the attribute associated with the code \a code. If the |
746 | attribute has not been set, it returns \a defaultValue. |
747 | |
748 | \note This function does not apply the defaults listed in |
749 | QNetworkRequest::Attribute. |
750 | |
751 | \sa setAttribute(), QNetworkRequest::Attribute |
752 | */ |
753 | QVariant QNetworkRequest::attribute(Attribute code, const QVariant &defaultValue) const |
754 | { |
755 | return d->attributes.value(key: code, defaultValue); |
756 | } |
757 | |
758 | /*! |
759 | Sets the attribute associated with code \a code to be value \a |
760 | value. If the attribute is already set, the previous value is |
761 | discarded. In special, if \a value is an invalid QVariant, the |
762 | attribute is unset. |
763 | |
764 | \sa attribute(), QNetworkRequest::Attribute |
765 | */ |
766 | void QNetworkRequest::setAttribute(Attribute code, const QVariant &value) |
767 | { |
768 | if (value.isValid()) |
769 | d->attributes.insert(key: code, value); |
770 | else |
771 | d->attributes.remove(key: code); |
772 | } |
773 | |
774 | #ifndef QT_NO_SSL |
775 | /*! |
776 | Returns this network request's SSL configuration. By default this is the same |
777 | as QSslConfiguration::defaultConfiguration(). |
778 | |
779 | \sa setSslConfiguration(), QSslConfiguration::defaultConfiguration() |
780 | */ |
781 | QSslConfiguration QNetworkRequest::sslConfiguration() const |
782 | { |
783 | if (!d->sslConfiguration) |
784 | d->sslConfiguration = new QSslConfiguration(QSslConfiguration::defaultConfiguration()); |
785 | return *d->sslConfiguration; |
786 | } |
787 | |
788 | /*! |
789 | Sets this network request's SSL configuration to be \a config. The |
790 | settings that apply are the private key, the local certificate, |
791 | the TLS protocol (e.g. TLS 1.3), the CA certificates and the ciphers that |
792 | the SSL backend is allowed to use. |
793 | |
794 | \sa sslConfiguration(), QSslConfiguration::defaultConfiguration() |
795 | */ |
796 | void QNetworkRequest::setSslConfiguration(const QSslConfiguration &config) |
797 | { |
798 | if (!d->sslConfiguration) |
799 | d->sslConfiguration = new QSslConfiguration(config); |
800 | else |
801 | *d->sslConfiguration = config; |
802 | } |
803 | #endif |
804 | |
805 | /*! |
806 | \since 4.6 |
807 | |
808 | Allows setting a reference to the \a object initiating |
809 | the request. |
810 | |
811 | For example Qt WebKit sets the originating object to the |
812 | QWebFrame that initiated the request. |
813 | |
814 | \sa originatingObject() |
815 | */ |
816 | void QNetworkRequest::setOriginatingObject(QObject *object) |
817 | { |
818 | d->originatingObject = object; |
819 | } |
820 | |
821 | /*! |
822 | \since 4.6 |
823 | |
824 | Returns a reference to the object that initiated this |
825 | network request; returns \nullptr if not set or the object has |
826 | been destroyed. |
827 | |
828 | \sa setOriginatingObject() |
829 | */ |
830 | QObject *QNetworkRequest::originatingObject() const |
831 | { |
832 | return d->originatingObject.data(); |
833 | } |
834 | |
835 | /*! |
836 | \since 4.7 |
837 | |
838 | Return the priority of this request. |
839 | |
840 | \sa setPriority() |
841 | */ |
842 | QNetworkRequest::Priority QNetworkRequest::priority() const |
843 | { |
844 | return d->priority; |
845 | } |
846 | |
847 | /*! \enum QNetworkRequest::Priority |
848 | |
849 | \since 4.7 |
850 | |
851 | This enum lists the possible network request priorities. |
852 | |
853 | \value HighPriority High priority |
854 | \value NormalPriority Normal priority |
855 | \value LowPriority Low priority |
856 | */ |
857 | |
858 | /*! |
859 | \since 4.7 |
860 | |
861 | Set the priority of this request to \a priority. |
862 | |
863 | \note The \a priority is only a hint to the network access |
864 | manager. It can use it or not. Currently it is used for HTTP to |
865 | decide which request should be sent first to a server. |
866 | |
867 | \sa priority() |
868 | */ |
869 | void QNetworkRequest::setPriority(Priority priority) |
870 | { |
871 | d->priority = priority; |
872 | } |
873 | |
874 | /*! |
875 | \since 5.6 |
876 | |
877 | Returns the maximum number of redirects allowed to be followed for this |
878 | request. |
879 | |
880 | \sa setMaximumRedirectsAllowed() |
881 | */ |
882 | int QNetworkRequest::maximumRedirectsAllowed() const |
883 | { |
884 | return d->maxRedirectsAllowed; |
885 | } |
886 | |
887 | /*! |
888 | \since 5.6 |
889 | |
890 | Sets the maximum number of redirects allowed to be followed for this |
891 | request to \a maxRedirectsAllowed. |
892 | |
893 | \sa maximumRedirectsAllowed() |
894 | */ |
895 | void QNetworkRequest::setMaximumRedirectsAllowed(int maxRedirectsAllowed) |
896 | { |
897 | d->maxRedirectsAllowed = maxRedirectsAllowed; |
898 | } |
899 | |
900 | /*! |
901 | \since 5.13 |
902 | |
903 | Returns the host name set for the certificate validation, as set by |
904 | setPeerVerifyName. By default this returns a null string. |
905 | |
906 | \sa setPeerVerifyName |
907 | */ |
908 | QString QNetworkRequest::peerVerifyName() const |
909 | { |
910 | return d->peerVerifyName; |
911 | } |
912 | |
913 | /*! |
914 | \since 5.13 |
915 | |
916 | Sets \a peerName as host name for the certificate validation, instead of the one used for the |
917 | TCP connection. |
918 | |
919 | \sa peerVerifyName |
920 | */ |
921 | void QNetworkRequest::setPeerVerifyName(const QString &peerName) |
922 | { |
923 | d->peerVerifyName = peerName; |
924 | } |
925 | |
926 | #if QT_CONFIG(http) |
927 | /*! |
928 | \since 6.5 |
929 | |
930 | Returns the current parameters that QNetworkAccessManager is |
931 | using for the underlying HTTP/1 connection of this request. |
932 | |
933 | \sa setHttp1Configuration |
934 | */ |
935 | QHttp1Configuration QNetworkRequest::http1Configuration() const |
936 | { |
937 | return d->h1Configuration; |
938 | } |
939 | /*! |
940 | \since 6.5 |
941 | |
942 | Sets request's HTTP/1 parameters from \a configuration. |
943 | |
944 | \sa http1Configuration, QNetworkAccessManager, QHttp1Configuration |
945 | */ |
946 | void QNetworkRequest::setHttp1Configuration(const QHttp1Configuration &configuration) |
947 | { |
948 | d->h1Configuration = configuration; |
949 | } |
950 | |
951 | /*! |
952 | \since 5.14 |
953 | |
954 | Returns the current parameters that QNetworkAccessManager is |
955 | using for this request and its underlying HTTP/2 connection. |
956 | This is either a configuration previously set by an application |
957 | or a default configuration. |
958 | |
959 | The default values that QNetworkAccessManager is using are: |
960 | |
961 | \list |
962 | \li Window size for connection-level flowcontrol is 2147483647 octets |
963 | \li Window size for stream-level flowcontrol is 214748364 octets |
964 | \li Max frame size is 16384 |
965 | \endlist |
966 | |
967 | By default, server push is disabled, Huffman compression and |
968 | string indexing are enabled. |
969 | |
970 | \sa setHttp2Configuration |
971 | */ |
972 | QHttp2Configuration QNetworkRequest::http2Configuration() const |
973 | { |
974 | return d->h2Configuration; |
975 | } |
976 | |
977 | /*! |
978 | \since 5.14 |
979 | |
980 | Sets request's HTTP/2 parameters from \a configuration. |
981 | |
982 | \note The configuration must be set prior to making a request. |
983 | \note HTTP/2 multiplexes several streams in a single HTTP/2 |
984 | connection. This implies that QNetworkAccessManager will use |
985 | the configuration found in the first request from a series |
986 | of requests sent to the same host. |
987 | |
988 | \sa http2Configuration, QNetworkAccessManager, QHttp2Configuration |
989 | */ |
990 | void QNetworkRequest::setHttp2Configuration(const QHttp2Configuration &configuration) |
991 | { |
992 | d->h2Configuration = configuration; |
993 | } |
994 | |
995 | /*! |
996 | \since 6.2 |
997 | |
998 | Returns the threshold for archive bomb checks. |
999 | |
1000 | If the decompressed size of a reply is smaller than this, Qt will simply |
1001 | decompress it, without further checking. |
1002 | |
1003 | \sa setDecompressedSafetyCheckThreshold() |
1004 | */ |
1005 | qint64 QNetworkRequest::decompressedSafetyCheckThreshold() const |
1006 | { |
1007 | return d->decompressedSafetyCheckThreshold; |
1008 | } |
1009 | |
1010 | /*! |
1011 | \since 6.2 |
1012 | |
1013 | Sets the \a threshold for archive bomb checks. |
1014 | |
1015 | Some supported compression algorithms can, in a tiny compressed file, encode |
1016 | a spectacularly huge decompressed file. This is only possible if the |
1017 | decompressed content is extremely monotonous, which is seldom the case for |
1018 | real files being transmitted in good faith: files exercising such insanely |
1019 | high compression ratios are typically payloads of buffer-overrun attacks, or |
1020 | denial-of-service (by using up too much memory) attacks. Consequently, files |
1021 | that decompress to huge sizes, particularly from tiny compressed forms, are |
1022 | best rejected as suspected malware. |
1023 | |
1024 | If a reply's decompressed size is bigger than this threshold (by default, |
1025 | 10 MiB, i.e. 10 * 1024 * 1024), Qt will check the compression ratio: if that |
1026 | is unreasonably large (40:1 for GZip and Deflate, or 100:1 for Brotli and |
1027 | ZStandard), the reply will be treated as an error. Setting the threshold |
1028 | to \c{-1} disables this check. |
1029 | |
1030 | \sa decompressedSafetyCheckThreshold() |
1031 | */ |
1032 | void QNetworkRequest::setDecompressedSafetyCheckThreshold(qint64 threshold) |
1033 | { |
1034 | d->decompressedSafetyCheckThreshold = threshold; |
1035 | } |
1036 | #endif // QT_CONFIG(http) |
1037 | |
1038 | #if QT_CONFIG(http) || defined (Q_OS_WASM) |
1039 | /*! |
1040 | \fn int QNetworkRequest::transferTimeout() const |
1041 | \since 5.15 |
1042 | |
1043 | Returns the timeout used for transfers, in milliseconds. |
1044 | |
1045 | If transferTimeoutAsDuration().count() cannot be represented in \c{int}, |
1046 | this function returns \c{INT_MAX}/\c{INT_MIN} instead. |
1047 | |
1048 | \sa setTransferTimeout(), transferTimeoutAsDuration() |
1049 | */ |
1050 | |
1051 | /*! |
1052 | \fn void QNetworkRequest::setTransferTimeout(int timeout) |
1053 | \since 5.15 |
1054 | |
1055 | Sets \a timeout as the transfer timeout in milliseconds. |
1056 | |
1057 | \sa setTransferTimeout(std::chrono::milliseconds), |
1058 | transferTimeout(), transferTimeoutAsDuration() |
1059 | */ |
1060 | |
1061 | /*! |
1062 | \since 6.7 |
1063 | |
1064 | Returns the timeout duration after which the transfer is aborted if no |
1065 | data is exchanged. |
1066 | |
1067 | The default duration is zero, which means that the timeout is not used. |
1068 | |
1069 | \sa setTransferTimeout(std::chrono::milliseconds) |
1070 | */ |
1071 | std::chrono::milliseconds QNetworkRequest::transferTimeoutAsDuration() const |
1072 | { |
1073 | return d->transferTimeout; |
1074 | } |
1075 | |
1076 | /*! |
1077 | \since 6.7 |
1078 | |
1079 | Sets the timeout \a duration to abort the transfer if no data is exchanged. |
1080 | |
1081 | Transfers are aborted if no bytes are transferred before |
1082 | the timeout expires. Zero means no timer is set. If no |
1083 | argument is provided, the timeout is |
1084 | QNetworkRequest::DefaultTransferTimeout. If this function |
1085 | is not called, the timeout is disabled and has the |
1086 | value zero. |
1087 | |
1088 | \sa transferTimeoutAsDuration() |
1089 | */ |
1090 | void QNetworkRequest::setTransferTimeout(std::chrono::milliseconds duration) |
1091 | { |
1092 | d->transferTimeout = duration; |
1093 | } |
1094 | #endif // QT_CONFIG(http) || defined (Q_OS_WASM) |
1095 | |
1096 | namespace { |
1097 | |
1098 | struct HeaderPair { |
1099 | QHttpHeaders::WellKnownHeader wellKnownHeader; |
1100 | QNetworkRequest::KnownHeaders knownHeader; |
1101 | }; |
1102 | |
1103 | constexpr bool operator<(const HeaderPair &lhs, const HeaderPair &rhs) |
1104 | { |
1105 | return lhs.wellKnownHeader < rhs.wellKnownHeader; |
1106 | } |
1107 | |
1108 | constexpr bool operator<(const HeaderPair &lhs, QHttpHeaders::WellKnownHeader rhs) |
1109 | { |
1110 | return lhs.wellKnownHeader < rhs; |
1111 | } |
1112 | |
1113 | constexpr bool operator<(QHttpHeaders::WellKnownHeader lhs, const HeaderPair &rhs) |
1114 | { |
1115 | return lhs < rhs.wellKnownHeader; |
1116 | } |
1117 | |
1118 | } // anonymous namespace |
1119 | |
1120 | static constexpr HeaderPair knownHeadersArr[] = { |
1121 | { .wellKnownHeader: QHttpHeaders::WellKnownHeader::ContentDisposition, .knownHeader: QNetworkRequest::KnownHeaders::ContentDispositionHeader }, |
1122 | { .wellKnownHeader: QHttpHeaders::WellKnownHeader::ContentLength, .knownHeader: QNetworkRequest::KnownHeaders::ContentLengthHeader }, |
1123 | { .wellKnownHeader: QHttpHeaders::WellKnownHeader::ContentType, .knownHeader: QNetworkRequest::KnownHeaders::ContentTypeHeader }, |
1124 | { .wellKnownHeader: QHttpHeaders::WellKnownHeader::Cookie, .knownHeader: QNetworkRequest::KnownHeaders::CookieHeader }, |
1125 | { .wellKnownHeader: QHttpHeaders::WellKnownHeader::ETag, .knownHeader: QNetworkRequest::KnownHeaders::ETagHeader }, |
1126 | { .wellKnownHeader: QHttpHeaders::WellKnownHeader::IfMatch , .knownHeader: QNetworkRequest::KnownHeaders::IfMatchHeader }, |
1127 | { .wellKnownHeader: QHttpHeaders::WellKnownHeader::IfModifiedSince, .knownHeader: QNetworkRequest::KnownHeaders::IfModifiedSinceHeader }, |
1128 | { .wellKnownHeader: QHttpHeaders::WellKnownHeader::IfNoneMatch, .knownHeader: QNetworkRequest::KnownHeaders::IfNoneMatchHeader }, |
1129 | { .wellKnownHeader: QHttpHeaders::WellKnownHeader::LastModified, .knownHeader: QNetworkRequest::KnownHeaders::LastModifiedHeader}, |
1130 | { .wellKnownHeader: QHttpHeaders::WellKnownHeader::Location, .knownHeader: QNetworkRequest::KnownHeaders::LocationHeader}, |
1131 | { .wellKnownHeader: QHttpHeaders::WellKnownHeader::Server, .knownHeader: QNetworkRequest::KnownHeaders::ServerHeader }, |
1132 | { .wellKnownHeader: QHttpHeaders::WellKnownHeader::SetCookie, .knownHeader: QNetworkRequest::KnownHeaders::SetCookieHeader }, |
1133 | { .wellKnownHeader: QHttpHeaders::WellKnownHeader::UserAgent, .knownHeader: QNetworkRequest::KnownHeaders::UserAgentHeader } |
1134 | }; |
1135 | |
1136 | static_assert(std::size(knownHeadersArr) == size_t(QNetworkRequest::KnownHeaders::NumKnownHeaders)); |
1137 | static_assert(q20::is_sorted(first: std::begin(arr: knownHeadersArr), last: std::end(arr: knownHeadersArr))); |
1138 | |
1139 | static std::optional<QNetworkRequest::KnownHeaders> toKnownHeader(QHttpHeaders::WellKnownHeader key) |
1140 | { |
1141 | const auto it = std::lower_bound(std::begin(arr: knownHeadersArr), std::end(arr: knownHeadersArr), key); |
1142 | if (it == std::end(arr: knownHeadersArr) || key < *it) |
1143 | return std::nullopt; |
1144 | return it->knownHeader; |
1145 | } |
1146 | |
1147 | static std::optional<QHttpHeaders::WellKnownHeader> toWellKnownHeader(QNetworkRequest::KnownHeaders key) |
1148 | { |
1149 | auto pred = [key](const HeaderPair &pair) { return pair.knownHeader == key; }; |
1150 | const auto it = std::find_if(first: std::begin(arr: knownHeadersArr), last: std::end(arr: knownHeadersArr), pred: pred); |
1151 | if (it == std::end(arr: knownHeadersArr)) |
1152 | return std::nullopt; |
1153 | return it->wellKnownHeader; |
1154 | } |
1155 | |
1156 | static QByteArray makeCookieHeader(const QList<QNetworkCookie> &cookies, |
1157 | QNetworkCookie::RawForm type, |
1158 | QByteArrayView separator) |
1159 | { |
1160 | QByteArray result; |
1161 | for (const QNetworkCookie &cookie : cookies) { |
1162 | result += cookie.toRawForm(form: type); |
1163 | result += separator; |
1164 | } |
1165 | if (!result.isEmpty()) |
1166 | result.chop(n: separator.size()); |
1167 | return result; |
1168 | } |
1169 | |
1170 | static QByteArray makeCookieHeader(const QVariant &value, QNetworkCookie::RawForm type, |
1171 | QByteArrayView separator) |
1172 | { |
1173 | const QList<QNetworkCookie> *cookies = get_if<QList<QNetworkCookie>>(v: &value); |
1174 | if (!cookies) |
1175 | return {}; |
1176 | return makeCookieHeader(cookies: *cookies, type, separator); |
1177 | } |
1178 | |
1179 | static QByteArray headerValue(QNetworkRequest::KnownHeaders header, const QVariant &value) |
1180 | { |
1181 | switch (header) { |
1182 | case QNetworkRequest::ContentTypeHeader: |
1183 | case QNetworkRequest::ContentLengthHeader: |
1184 | case QNetworkRequest::ContentDispositionHeader: |
1185 | case QNetworkRequest::UserAgentHeader: |
1186 | case QNetworkRequest::ServerHeader: |
1187 | case QNetworkRequest::ETagHeader: |
1188 | case QNetworkRequest::IfMatchHeader: |
1189 | case QNetworkRequest::IfNoneMatchHeader: |
1190 | return value.toByteArray(); |
1191 | |
1192 | case QNetworkRequest::LocationHeader: |
1193 | switch (value.userType()) { |
1194 | case QMetaType::QUrl: |
1195 | return value.toUrl().toEncoded(); |
1196 | |
1197 | default: |
1198 | return value.toByteArray(); |
1199 | } |
1200 | |
1201 | case QNetworkRequest::LastModifiedHeader: |
1202 | case QNetworkRequest::IfModifiedSinceHeader: |
1203 | switch (value.userType()) { |
1204 | // Generate RFC 1123/822 dates: |
1205 | case QMetaType::QDate: |
1206 | return QNetworkHeadersPrivate::toHttpDate(dt: value.toDate().startOfDay(zone: QTimeZone::UTC)); |
1207 | case QMetaType::QDateTime: |
1208 | return QNetworkHeadersPrivate::toHttpDate(dt: value.toDateTime()); |
1209 | |
1210 | default: |
1211 | return value.toByteArray(); |
1212 | } |
1213 | |
1214 | case QNetworkRequest::CookieHeader: |
1215 | return makeCookieHeader(value, type: QNetworkCookie::NameAndValueOnly, separator: "; "); |
1216 | |
1217 | case QNetworkRequest::SetCookieHeader: |
1218 | return makeCookieHeader(value, type: QNetworkCookie::Full, separator: ", "); |
1219 | |
1220 | default: |
1221 | Q_UNREACHABLE_RETURN({}); |
1222 | } |
1223 | } |
1224 | |
1225 | static int parseHeaderName(QByteArrayView headerName) |
1226 | { |
1227 | if (headerName.isEmpty()) |
1228 | return -1; |
1229 | |
1230 | auto is = [headerName](QByteArrayView what) { |
1231 | return headerName.compare(a: what, cs: Qt::CaseInsensitive) == 0; |
1232 | }; |
1233 | |
1234 | switch (QtMiscUtils::toAsciiLower(ch: headerName.front())) { |
1235 | case 'c': |
1236 | if (is("content-type")) |
1237 | return QNetworkRequest::ContentTypeHeader; |
1238 | else if (is("content-length")) |
1239 | return QNetworkRequest::ContentLengthHeader; |
1240 | else if (is("cookie")) |
1241 | return QNetworkRequest::CookieHeader; |
1242 | else if (is("content-disposition")) |
1243 | return QNetworkRequest::ContentDispositionHeader; |
1244 | break; |
1245 | |
1246 | case 'e': |
1247 | if (is("etag")) |
1248 | return QNetworkRequest::ETagHeader; |
1249 | break; |
1250 | |
1251 | case 'i': |
1252 | if (is("if-modified-since")) |
1253 | return QNetworkRequest::IfModifiedSinceHeader; |
1254 | if (is("if-match")) |
1255 | return QNetworkRequest::IfMatchHeader; |
1256 | if (is("if-none-match")) |
1257 | return QNetworkRequest::IfNoneMatchHeader; |
1258 | break; |
1259 | |
1260 | case 'l': |
1261 | if (is("location")) |
1262 | return QNetworkRequest::LocationHeader; |
1263 | else if (is("last-modified")) |
1264 | return QNetworkRequest::LastModifiedHeader; |
1265 | break; |
1266 | |
1267 | case 's': |
1268 | if (is("set-cookie")) |
1269 | return QNetworkRequest::SetCookieHeader; |
1270 | else if (is("server")) |
1271 | return QNetworkRequest::ServerHeader; |
1272 | break; |
1273 | |
1274 | case 'u': |
1275 | if (is("user-agent")) |
1276 | return QNetworkRequest::UserAgentHeader; |
1277 | break; |
1278 | } |
1279 | |
1280 | return -1; // nothing found |
1281 | } |
1282 | |
1283 | static QVariant parseHttpDate(QByteArrayView raw) |
1284 | { |
1285 | QDateTime dt = QNetworkHeadersPrivate::fromHttpDate(value: raw); |
1286 | if (dt.isValid()) |
1287 | return dt; |
1288 | return QVariant(); // transform an invalid QDateTime into a null QVariant |
1289 | } |
1290 | |
1291 | static QList<QNetworkCookie> parseCookieHeader(QByteArrayView raw) |
1292 | { |
1293 | QList<QNetworkCookie> result; |
1294 | for (auto cookie : QLatin1StringView(raw).tokenize(needle: ';'_L1)) { |
1295 | QList<QNetworkCookie> parsed = QNetworkCookie::parseCookies(cookieString: cookie.trimmed()); |
1296 | if (parsed.size() != 1) |
1297 | return {}; // invalid Cookie: header |
1298 | |
1299 | result += parsed; |
1300 | } |
1301 | |
1302 | return result; |
1303 | } |
1304 | |
1305 | static QVariant parseETag(QByteArrayView raw) |
1306 | { |
1307 | const QByteArrayView trimmed = raw.trimmed(); |
1308 | if (!trimmed.startsWith(c: '"') && !trimmed.startsWith(other: R"(W/")")) |
1309 | return QVariant(); |
1310 | |
1311 | if (!trimmed.endsWith(c: '"')) |
1312 | return QVariant(); |
1313 | |
1314 | return QString::fromLatin1(ba: trimmed); |
1315 | } |
1316 | |
1317 | template<typename T> |
1318 | static QStringList parseMatchImpl(QByteArrayView raw, T op) |
1319 | { |
1320 | const QByteArrayView trimmedRaw = raw.trimmed(); |
1321 | if (trimmedRaw == "*") |
1322 | return QStringList(QStringLiteral("*")); |
1323 | |
1324 | QStringList tags; |
1325 | for (auto &element : QLatin1StringView(trimmedRaw).tokenize(needle: ','_L1)) { |
1326 | if (const auto trimmed = element.trimmed(); op(trimmed)) |
1327 | tags += QString::fromLatin1(ba: trimmed); |
1328 | } |
1329 | return tags; |
1330 | } |
1331 | |
1332 | |
1333 | static QStringList parseIfMatch(QByteArrayView raw) |
1334 | { |
1335 | return parseMatchImpl(raw, op: [](QByteArrayView element) { |
1336 | return element.startsWith(c: '"') && element.endsWith(c: '"'); |
1337 | }); |
1338 | } |
1339 | |
1340 | static QStringList parseIfNoneMatch(QByteArrayView raw) |
1341 | { |
1342 | return parseMatchImpl(raw, op: [](QByteArrayView element) { |
1343 | return (element.startsWith(c: '"') || element.startsWith(other: R"(W/")")) && element.endsWith(c: '"'); |
1344 | }); |
1345 | } |
1346 | |
1347 | |
1348 | static QVariant parseHeaderValue(QNetworkRequest::KnownHeaders header, QByteArrayView value) |
1349 | { |
1350 | // header is always a valid value |
1351 | switch (header) { |
1352 | case QNetworkRequest::UserAgentHeader: |
1353 | case QNetworkRequest::ServerHeader: |
1354 | case QNetworkRequest::ContentTypeHeader: |
1355 | case QNetworkRequest::ContentDispositionHeader: |
1356 | // copy exactly, convert to QString |
1357 | return QString::fromLatin1(ba: value); |
1358 | |
1359 | case QNetworkRequest::ContentLengthHeader: { |
1360 | bool ok; |
1361 | qint64 result = QByteArrayView(value).trimmed().toLongLong(ok: &ok); |
1362 | if (ok) |
1363 | return result; |
1364 | return QVariant(); |
1365 | } |
1366 | |
1367 | case QNetworkRequest::LocationHeader: { |
1368 | QUrl result = QUrl::fromEncoded(input: value, mode: QUrl::StrictMode); |
1369 | if (result.isValid() && !result.scheme().isEmpty()) |
1370 | return result; |
1371 | return QVariant(); |
1372 | } |
1373 | |
1374 | case QNetworkRequest::LastModifiedHeader: |
1375 | case QNetworkRequest::IfModifiedSinceHeader: |
1376 | return parseHttpDate(raw: value); |
1377 | |
1378 | case QNetworkRequest::ETagHeader: |
1379 | return parseETag(raw: value); |
1380 | |
1381 | case QNetworkRequest::IfMatchHeader: |
1382 | return parseIfMatch(raw: value); |
1383 | |
1384 | case QNetworkRequest::IfNoneMatchHeader: |
1385 | return parseIfNoneMatch(raw: value); |
1386 | |
1387 | case QNetworkRequest::CookieHeader: |
1388 | return QVariant::fromValue(value: parseCookieHeader(raw: value)); |
1389 | |
1390 | case QNetworkRequest::SetCookieHeader: |
1391 | return QVariant::fromValue(value: QNetworkCookie::parseCookies(cookieString: value)); |
1392 | |
1393 | default: |
1394 | Q_UNREACHABLE_RETURN({}); |
1395 | } |
1396 | } |
1397 | |
1398 | static QVariant parseHeaderValue(QNetworkRequest::KnownHeaders header, QList<QByteArray> values) |
1399 | { |
1400 | if (values.empty()) |
1401 | return QVariant(); |
1402 | |
1403 | // header is always a valid value |
1404 | switch (header) { |
1405 | case QNetworkRequest::IfMatchHeader: { |
1406 | QStringList res; |
1407 | for (const auto &val : values) |
1408 | res << parseIfMatch(raw: val); |
1409 | return res; |
1410 | } |
1411 | case QNetworkRequest::IfNoneMatchHeader: { |
1412 | QStringList res; |
1413 | for (const auto &val : values) |
1414 | res << parseIfNoneMatch(raw: val); |
1415 | return res; |
1416 | } |
1417 | case QNetworkRequest::CookieHeader: { |
1418 | auto listOpt = QNetworkHeadersPrivate::toCookieList(values); |
1419 | return listOpt.has_value() ? QVariant::fromValue(value: listOpt.value()) : QVariant(); |
1420 | } |
1421 | case QNetworkRequest::SetCookieHeader: { |
1422 | QList<QNetworkCookie> res; |
1423 | for (const auto &val : values) |
1424 | res << QNetworkCookie::parseCookies(cookieString: val); |
1425 | return QVariant::fromValue(value: res); |
1426 | } |
1427 | default: |
1428 | return parseHeaderValue(header, value: values.first()); |
1429 | } |
1430 | return QVariant(); |
1431 | } |
1432 | |
1433 | static bool isSetCookie(QByteArrayView name) |
1434 | { |
1435 | return name.compare(a: QHttpHeaders::wellKnownHeaderName(name: QHttpHeaders::WellKnownHeader::SetCookie), |
1436 | cs: Qt::CaseInsensitive) == 0; |
1437 | } |
1438 | |
1439 | static bool isSetCookie(QHttpHeaders::WellKnownHeader name) |
1440 | { |
1441 | return name == QHttpHeaders::WellKnownHeader::SetCookie; |
1442 | } |
1443 | |
1444 | template<class HeaderName> |
1445 | static void setFromRawHeader(QHttpHeaders &headers, HeaderName header, |
1446 | QByteArrayView value) |
1447 | { |
1448 | headers.removeAll(header); |
1449 | |
1450 | if (value.isNull()) |
1451 | // only wanted to erase key |
1452 | return; |
1453 | |
1454 | if (isSetCookie(header)) { |
1455 | for (auto cookie : QLatin1StringView(value).tokenize(needle: '\n'_L1)) |
1456 | headers.append(name: QHttpHeaders::WellKnownHeader::SetCookie, value: cookie); |
1457 | } else { |
1458 | headers.append(header, value); |
1459 | } |
1460 | } |
1461 | |
1462 | const QNetworkHeadersPrivate::RawHeadersList &QNetworkHeadersPrivate::allRawHeaders() const |
1463 | { |
1464 | if (rawHeaderCache.isCached) |
1465 | return rawHeaderCache.headersList; |
1466 | |
1467 | rawHeaderCache.headersList = fromHttpToRaw(headers: httpHeaders); |
1468 | rawHeaderCache.isCached = true; |
1469 | return rawHeaderCache.headersList; |
1470 | } |
1471 | |
1472 | QList<QByteArray> QNetworkHeadersPrivate::rawHeadersKeys() const |
1473 | { |
1474 | if (httpHeaders.isEmpty()) |
1475 | return {}; |
1476 | |
1477 | QList<QByteArray> result; |
1478 | result.reserve(size: httpHeaders.size()); |
1479 | QDuplicateTracker<QByteArray> seen(httpHeaders.size()); |
1480 | |
1481 | for (qsizetype i = 0; i < httpHeaders.size(); i++) { |
1482 | const auto nameL1 = httpHeaders.nameAt(i); |
1483 | const auto name = QByteArray(nameL1.data(), nameL1.size()); |
1484 | if (seen.hasSeen(s: name)) |
1485 | continue; |
1486 | |
1487 | result << name; |
1488 | } |
1489 | |
1490 | return result; |
1491 | } |
1492 | |
1493 | QByteArray QNetworkHeadersPrivate::rawHeader(QAnyStringView headerName) const |
1494 | { |
1495 | QByteArrayView setCookieStr = QHttpHeaders::wellKnownHeaderName( |
1496 | name: QHttpHeaders::WellKnownHeader::SetCookie); |
1497 | if (QAnyStringView::compare(lhs: headerName, rhs: setCookieStr, cs: Qt::CaseInsensitive) != 0) |
1498 | return httpHeaders.combinedValue(name: headerName); |
1499 | |
1500 | QByteArray result; |
1501 | const char* separator = ""; |
1502 | for (qsizetype i = 0; i < httpHeaders.size(); ++i) { |
1503 | if (QAnyStringView::compare(lhs: httpHeaders.nameAt(i), rhs: headerName, cs: Qt::CaseInsensitive) == 0) { |
1504 | result.append(s: separator); |
1505 | result.append(a: httpHeaders.valueAt(i)); |
1506 | separator = "\n"; |
1507 | } |
1508 | } |
1509 | return result; |
1510 | } |
1511 | |
1512 | void QNetworkHeadersPrivate::setRawHeader(const QByteArray &key, const QByteArray &value) |
1513 | { |
1514 | if (key.isEmpty()) |
1515 | // refuse to accept an empty raw header |
1516 | return; |
1517 | |
1518 | setFromRawHeader(headers&: httpHeaders, header: key, value); |
1519 | parseAndSetHeader(key, value); |
1520 | |
1521 | invalidateHeaderCache(); |
1522 | } |
1523 | |
1524 | void QNetworkHeadersPrivate::setCookedHeader(QNetworkRequest::KnownHeaders header, |
1525 | const QVariant &value) |
1526 | { |
1527 | const auto wellKnownOpt = toWellKnownHeader(key: header); |
1528 | if (!wellKnownOpt) { |
1529 | // verifies that \a header is a known value |
1530 | qWarning(msg: "QNetworkRequest::setHeader: invalid header value KnownHeader(%d) received", header); |
1531 | return; |
1532 | } |
1533 | |
1534 | if (value.isNull()) { |
1535 | httpHeaders.removeAll(name: wellKnownOpt.value()); |
1536 | cookedHeaders.remove(key: header); |
1537 | } else { |
1538 | QByteArray rawValue = headerValue(header, value); |
1539 | if (rawValue.isEmpty()) { |
1540 | qWarning(msg: "QNetworkRequest::setHeader: QVariant of type %s cannot be used with header %s", |
1541 | value.typeName(), |
1542 | QHttpHeaders::wellKnownHeaderName(name: wellKnownOpt.value()).constData()); |
1543 | return; |
1544 | } |
1545 | |
1546 | setFromRawHeader(headers&: httpHeaders, header: wellKnownOpt.value(), value: rawValue); |
1547 | cookedHeaders.insert(key: header, value); |
1548 | } |
1549 | |
1550 | invalidateHeaderCache(); |
1551 | } |
1552 | |
1553 | QHttpHeaders QNetworkHeadersPrivate::headers() const |
1554 | { |
1555 | return httpHeaders; |
1556 | } |
1557 | |
1558 | void QNetworkHeadersPrivate::setHeaders(const QHttpHeaders &newHeaders) |
1559 | { |
1560 | httpHeaders = newHeaders; |
1561 | setCookedFromHttp(httpHeaders); |
1562 | invalidateHeaderCache(); |
1563 | } |
1564 | |
1565 | void QNetworkHeadersPrivate::setHeaders(QHttpHeaders &&newHeaders) |
1566 | { |
1567 | httpHeaders = std::move(newHeaders); |
1568 | setCookedFromHttp(httpHeaders); |
1569 | invalidateHeaderCache(); |
1570 | } |
1571 | |
1572 | void QNetworkHeadersPrivate::setHeader(QHttpHeaders::WellKnownHeader name, QByteArrayView value) |
1573 | { |
1574 | httpHeaders.replaceOrAppend(name, newValue: value); |
1575 | |
1576 | // set cooked header |
1577 | const auto knownHeaderOpt = toKnownHeader(key: name); |
1578 | if (knownHeaderOpt) |
1579 | parseAndSetHeader(key: knownHeaderOpt.value(), value); |
1580 | |
1581 | invalidateHeaderCache(); |
1582 | } |
1583 | |
1584 | void QNetworkHeadersPrivate::clearHeaders() |
1585 | { |
1586 | httpHeaders.clear(); |
1587 | cookedHeaders.clear(); |
1588 | invalidateHeaderCache(); |
1589 | } |
1590 | |
1591 | void QNetworkHeadersPrivate::parseAndSetHeader(QByteArrayView key, QByteArrayView value) |
1592 | { |
1593 | // is it a known header? |
1594 | const int parsedKeyAsInt = parseHeaderName(headerName: key); |
1595 | if (parsedKeyAsInt != -1) { |
1596 | const QNetworkRequest::KnownHeaders parsedKey |
1597 | = static_cast<QNetworkRequest::KnownHeaders>(parsedKeyAsInt); |
1598 | parseAndSetHeader(key: parsedKey, value); |
1599 | } |
1600 | } |
1601 | |
1602 | void QNetworkHeadersPrivate::parseAndSetHeader(QNetworkRequest::KnownHeaders key, |
1603 | QByteArrayView value) |
1604 | { |
1605 | if (value.isNull()) { |
1606 | cookedHeaders.remove(key); |
1607 | } else if (key == QNetworkRequest::ContentLengthHeader |
1608 | && cookedHeaders.contains(key: QNetworkRequest::ContentLengthHeader)) { |
1609 | // Only set the cooked header "Content-Length" once. |
1610 | // See bug QTBUG-15311 |
1611 | } else { |
1612 | cookedHeaders.insert(key, value: parseHeaderValue(header: key, value)); |
1613 | } |
1614 | } |
1615 | |
1616 | // Fast month string to int conversion. This code |
1617 | // assumes that the Month name is correct and that |
1618 | // the string is at least three chars long. |
1619 | static int name_to_month(const char* month_str) |
1620 | { |
1621 | switch (month_str[0]) { |
1622 | case 'J': |
1623 | switch (month_str[1]) { |
1624 | case 'a': |
1625 | return 1; |
1626 | case 'u': |
1627 | switch (month_str[2] ) { |
1628 | case 'n': |
1629 | return 6; |
1630 | case 'l': |
1631 | return 7; |
1632 | } |
1633 | } |
1634 | break; |
1635 | case 'F': |
1636 | return 2; |
1637 | case 'M': |
1638 | switch (month_str[2] ) { |
1639 | case 'r': |
1640 | return 3; |
1641 | case 'y': |
1642 | return 5; |
1643 | } |
1644 | break; |
1645 | case 'A': |
1646 | switch (month_str[1]) { |
1647 | case 'p': |
1648 | return 4; |
1649 | case 'u': |
1650 | return 8; |
1651 | } |
1652 | break; |
1653 | case 'O': |
1654 | return 10; |
1655 | case 'S': |
1656 | return 9; |
1657 | case 'N': |
1658 | return 11; |
1659 | case 'D': |
1660 | return 12; |
1661 | } |
1662 | |
1663 | return 0; |
1664 | } |
1665 | |
1666 | QDateTime QNetworkHeadersPrivate::fromHttpDate(QByteArrayView value) |
1667 | { |
1668 | // HTTP dates have three possible formats: |
1669 | // RFC 1123/822 - ddd, dd MMM yyyy hh:mm:ss "GMT" |
1670 | // RFC 850 - dddd, dd-MMM-yy hh:mm:ss "GMT" |
1671 | // ANSI C's asctime - ddd MMM d hh:mm:ss yyyy |
1672 | // We only handle them exactly. If they deviate, we bail out. |
1673 | |
1674 | int pos = value.indexOf(ch: ','); |
1675 | QDateTime dt; |
1676 | #if QT_CONFIG(datestring) |
1677 | if (pos == -1) { |
1678 | // no comma -> asctime(3) format |
1679 | dt = QDateTime::fromString(string: QString::fromLatin1(ba: value), format: Qt::TextDate); |
1680 | } else { |
1681 | // Use sscanf over QLocal/QDateTimeParser for speed reasons. See the |
1682 | // Qt WebKit performance benchmarks to get an idea. |
1683 | if (pos == 3) { |
1684 | char month_name[4]; |
1685 | int day, year, hour, minute, second; |
1686 | #ifdef Q_CC_MSVC |
1687 | // Use secure version to avoid compiler warning |
1688 | if (sscanf_s(value.constData(), "%*3s, %d %3s %d %d:%d:%d 'GMT'", &day, month_name, 4, &year, &hour, &minute, &second) == 6) |
1689 | #else |
1690 | // The POSIX secure mode is %ms (which allocates memory), too bleeding edge for now |
1691 | // In any case this is already safe as field width is specified. |
1692 | if (sscanf(s: value.constData(), format: "%*3s, %d %3s %d %d:%d:%d 'GMT'", &day, month_name, &year, &hour, &minute, &second) == 6) |
1693 | #endif |
1694 | dt = QDateTime(QDate(year, name_to_month(month_str: month_name), day), QTime(hour, minute, second)); |
1695 | } else { |
1696 | QLocale c = QLocale::c(); |
1697 | // eat the weekday, the comma and the space following it |
1698 | QString sansWeekday = QString::fromLatin1(ba: value.constData() + pos + 2); |
1699 | // must be RFC 850 date |
1700 | dt = c.toDateTime(string: sansWeekday, format: "dd-MMM-yy hh:mm:ss 'GMT'"_L1); |
1701 | } |
1702 | } |
1703 | #endif // datestring |
1704 | |
1705 | if (dt.isValid()) |
1706 | dt.setTimeZone(toZone: QTimeZone::UTC); |
1707 | return dt; |
1708 | } |
1709 | |
1710 | QByteArray QNetworkHeadersPrivate::toHttpDate(const QDateTime &dt) |
1711 | { |
1712 | return QLocale::c().toString(dateTime: dt.toUTC(), format: u"ddd, dd MMM yyyy hh:mm:ss 'GMT'").toLatin1(); |
1713 | } |
1714 | |
1715 | QNetworkHeadersPrivate::RawHeadersList QNetworkHeadersPrivate::fromHttpToRaw( |
1716 | const QHttpHeaders &headers) |
1717 | { |
1718 | if (headers.isEmpty()) |
1719 | return {}; |
1720 | |
1721 | QNetworkHeadersPrivate::RawHeadersList list; |
1722 | QHash<QByteArray, qsizetype> nameToIndex; |
1723 | list.reserve(size: headers.size()); |
1724 | nameToIndex.reserve(size: headers.size()); |
1725 | |
1726 | for (qsizetype i = 0; i < headers.size(); ++i) { |
1727 | const auto nameL1 = headers.nameAt(i); |
1728 | const auto value = headers.valueAt(i); |
1729 | |
1730 | const bool isSetCookie = nameL1 == QHttpHeaders::wellKnownHeaderName( |
1731 | name: QHttpHeaders::WellKnownHeader::SetCookie); |
1732 | |
1733 | const auto name = QByteArray(nameL1.data(), nameL1.size()); |
1734 | if (auto it = nameToIndex.find(key: name); it != nameToIndex.end()) { |
1735 | list[it.value()].second += isSetCookie ? "\n": ", "; |
1736 | list[it.value()].second += value; |
1737 | } else { |
1738 | nameToIndex[name] = list.size(); |
1739 | list.emplaceBack(args: name, args: value.toByteArray()); |
1740 | } |
1741 | } |
1742 | |
1743 | return list; |
1744 | } |
1745 | |
1746 | QHttpHeaders QNetworkHeadersPrivate::fromRawToHttp(const RawHeadersList &raw) |
1747 | { |
1748 | if (raw.empty()) |
1749 | return {}; |
1750 | |
1751 | QHttpHeaders headers; |
1752 | headers.reserve(size: raw.size()); |
1753 | |
1754 | for (const auto &[key, value] : raw) { |
1755 | const bool isSetCookie = key.compare(a: QHttpHeaders::wellKnownHeaderName( |
1756 | name: QHttpHeaders::WellKnownHeader::SetCookie), |
1757 | cs: Qt::CaseInsensitive) == 0; |
1758 | if (isSetCookie) { |
1759 | for (auto header : QLatin1StringView(value).tokenize(needle: '\n'_L1)) |
1760 | headers.append(name: key, value: header); |
1761 | } else { |
1762 | headers.append(name: key, value); |
1763 | } |
1764 | } |
1765 | |
1766 | return headers; |
1767 | } |
1768 | |
1769 | std::optional<qint64> QNetworkHeadersPrivate::toInt(QByteArrayView value) |
1770 | { |
1771 | if (value.empty()) |
1772 | return std::nullopt; |
1773 | |
1774 | bool ok; |
1775 | qint64 res = value.toLongLong(ok: &ok); |
1776 | if (ok) |
1777 | return res; |
1778 | return std::nullopt; |
1779 | } |
1780 | |
1781 | std::optional<QNetworkHeadersPrivate::NetworkCookieList> QNetworkHeadersPrivate::toSetCookieList( |
1782 | const QList<QByteArray> &values) |
1783 | { |
1784 | if (values.empty()) |
1785 | return std::nullopt; |
1786 | |
1787 | QList<QNetworkCookie> cookies; |
1788 | for (const auto &s : values) |
1789 | cookies += QNetworkCookie::parseCookies(cookieString: s); |
1790 | |
1791 | if (cookies.empty()) |
1792 | return std::nullopt; |
1793 | return cookies; |
1794 | } |
1795 | |
1796 | QByteArray QNetworkHeadersPrivate::fromCookieList(const QList<QNetworkCookie> &cookies) |
1797 | { |
1798 | return makeCookieHeader(cookies, type: QNetworkCookie::NameAndValueOnly, separator: "; "); |
1799 | } |
1800 | |
1801 | std::optional<QNetworkHeadersPrivate::NetworkCookieList> QNetworkHeadersPrivate::toCookieList( |
1802 | const QList<QByteArray> &values) |
1803 | { |
1804 | if (values.empty()) |
1805 | return std::nullopt; |
1806 | |
1807 | QList<QNetworkCookie> cookies; |
1808 | for (const auto &s : values) |
1809 | cookies += parseCookieHeader(raw: s); |
1810 | |
1811 | if (cookies.empty()) |
1812 | return std::nullopt; |
1813 | return cookies; |
1814 | } |
1815 | |
1816 | void QNetworkHeadersPrivate::invalidateHeaderCache() |
1817 | { |
1818 | rawHeaderCache.headersList.clear(); |
1819 | rawHeaderCache.isCached = false; |
1820 | } |
1821 | |
1822 | void QNetworkHeadersPrivate::setCookedFromHttp(const QHttpHeaders &newHeaders) |
1823 | { |
1824 | cookedHeaders.clear(); |
1825 | |
1826 | QMap<QNetworkRequest::KnownHeaders, QList<QByteArray>> multipleHeadersMap; |
1827 | for (int i = 0; i < newHeaders.size(); ++i) { |
1828 | const auto name = newHeaders.nameAt(i); |
1829 | const auto value = newHeaders.valueAt(i); |
1830 | |
1831 | const int parsedKeyAsInt = parseHeaderName(headerName: name); |
1832 | if (parsedKeyAsInt == -1) |
1833 | continue; |
1834 | |
1835 | const QNetworkRequest::KnownHeaders parsedKey |
1836 | = static_cast<QNetworkRequest::KnownHeaders>(parsedKeyAsInt); |
1837 | |
1838 | auto &list = multipleHeadersMap[parsedKey]; |
1839 | list.append(t: value.toByteArray()); |
1840 | } |
1841 | |
1842 | for (auto i = multipleHeadersMap.cbegin(), end = multipleHeadersMap.cend(); i != end; ++i) |
1843 | cookedHeaders.insert(key: i.key(), value: parseHeaderValue(header: i.key(), values: i.value())); |
1844 | } |
1845 | |
1846 | QT_END_NAMESPACE |
1847 | |
1848 | #include "moc_qnetworkrequest.cpp" |
1849 |
Definitions
- QNetworkRequestPrivate
- QNetworkRequestPrivate
- ~QNetworkRequestPrivate
- QNetworkRequestPrivate
- operator==
- QNetworkRequest
- QNetworkRequest
- QNetworkRequest
- ~QNetworkRequest
- operator==
- operator=
- url
- setUrl
- headers
- setHeaders
- setHeaders
- header
- setHeader
- hasRawHeader
- rawHeader
- rawHeaderList
- setRawHeader
- attribute
- setAttribute
- sslConfiguration
- setSslConfiguration
- setOriginatingObject
- originatingObject
- priority
- setPriority
- maximumRedirectsAllowed
- setMaximumRedirectsAllowed
- peerVerifyName
- setPeerVerifyName
- http1Configuration
- setHttp1Configuration
- http2Configuration
- setHttp2Configuration
- decompressedSafetyCheckThreshold
- setDecompressedSafetyCheckThreshold
- transferTimeoutAsDuration
- setTransferTimeout
- HeaderPair
- operator<
- operator<
- operator<
- knownHeadersArr
- toKnownHeader
- toWellKnownHeader
- makeCookieHeader
- makeCookieHeader
- headerValue
- parseHeaderName
- parseHttpDate
- parseCookieHeader
- parseETag
- parseMatchImpl
- parseIfMatch
- parseIfNoneMatch
- parseHeaderValue
- parseHeaderValue
- isSetCookie
- isSetCookie
- setFromRawHeader
- allRawHeaders
- rawHeadersKeys
- rawHeader
- setRawHeader
- setCookedHeader
- headers
- setHeaders
- setHeaders
- setHeader
- clearHeaders
- parseAndSetHeader
- parseAndSetHeader
- name_to_month
- fromHttpDate
- toHttpDate
- fromHttpToRaw
- fromRawToHttp
- toInt
- toSetCookieList
- fromCookieList
- toCookieList
- invalidateHeaderCache
Learn Advanced QML with KDAB
Find out more