1/*
2 * Copyright (C) 2006, 2008 Apple Inc. All rights reserved.
3 * Copyright (C) 2009 Google Inc. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
15 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
18 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27#include "config.h"
28#include "platform/network/ResourceResponse.h"
29
30#include "wtf/CurrentTime.h"
31#include "wtf/StdLibExtras.h"
32
33namespace blink {
34
35ResourceResponse::ResourceResponse()
36    : m_expectedContentLength(0)
37    , m_httpStatusCode(0)
38    , m_lastModifiedDate(0)
39    , m_wasCached(false)
40    , m_connectionID(0)
41    , m_connectionReused(false)
42    , m_isNull(true)
43    , m_haveParsedAgeHeader(false)
44    , m_haveParsedDateHeader(false)
45    , m_haveParsedExpiresHeader(false)
46    , m_haveParsedLastModifiedHeader(false)
47    , m_age(0.0)
48    , m_date(0.0)
49    , m_expires(0.0)
50    , m_lastModified(0.0)
51    , m_httpVersion(Unknown)
52    , m_appCacheID(0)
53    , m_isMultipartPayload(false)
54    , m_wasFetchedViaSPDY(false)
55    , m_wasNpnNegotiated(false)
56    , m_wasAlternateProtocolAvailable(false)
57    , m_wasFetchedViaProxy(false)
58    , m_wasFetchedViaServiceWorker(false)
59    , m_responseTime(0)
60    , m_remotePort(0)
61{
62}
63
64ResourceResponse::ResourceResponse(const KURL& url, const AtomicString& mimeType, long long expectedLength, const AtomicString& textEncodingName, const String& filename)
65    : m_url(url)
66    , m_mimeType(mimeType)
67    , m_expectedContentLength(expectedLength)
68    , m_textEncodingName(textEncodingName)
69    , m_suggestedFilename(filename)
70    , m_httpStatusCode(0)
71    , m_lastModifiedDate(0)
72    , m_wasCached(false)
73    , m_connectionID(0)
74    , m_connectionReused(false)
75    , m_isNull(false)
76    , m_haveParsedAgeHeader(false)
77    , m_haveParsedDateHeader(false)
78    , m_haveParsedExpiresHeader(false)
79    , m_haveParsedLastModifiedHeader(false)
80    , m_age(0.0)
81    , m_date(0.0)
82    , m_expires(0.0)
83    , m_lastModified(0.0)
84    , m_httpVersion(Unknown)
85    , m_appCacheID(0)
86    , m_isMultipartPayload(false)
87    , m_wasFetchedViaSPDY(false)
88    , m_wasNpnNegotiated(false)
89    , m_wasAlternateProtocolAvailable(false)
90    , m_wasFetchedViaProxy(false)
91    , m_wasFetchedViaServiceWorker(false)
92    , m_responseTime(0)
93    , m_remotePort(0)
94{
95}
96
97PassOwnPtr<ResourceResponse> ResourceResponse::adopt(PassOwnPtr<CrossThreadResourceResponseData> data)
98{
99    OwnPtr<ResourceResponse> response = adoptPtr(new ResourceResponse);
100    response->setURL(data->m_url);
101    response->setMimeType(AtomicString(data->m_mimeType));
102    response->setExpectedContentLength(data->m_expectedContentLength);
103    response->setTextEncodingName(AtomicString(data->m_textEncodingName));
104    response->setSuggestedFilename(data->m_suggestedFilename);
105
106    response->setHTTPStatusCode(data->m_httpStatusCode);
107    response->setHTTPStatusText(AtomicString(data->m_httpStatusText));
108
109    response->m_httpHeaderFields.adopt(data->m_httpHeaders.release());
110    response->setLastModifiedDate(data->m_lastModifiedDate);
111    response->setResourceLoadTiming(data->m_resourceLoadTiming.release());
112    response->m_securityInfo = data->m_securityInfo;
113    response->m_httpVersion = data->m_httpVersion;
114    response->m_appCacheID = data->m_appCacheID;
115    response->m_appCacheManifestURL = data->m_appCacheManifestURL.copy();
116    response->m_isMultipartPayload = data->m_isMultipartPayload;
117    response->m_wasFetchedViaSPDY = data->m_wasFetchedViaSPDY;
118    response->m_wasNpnNegotiated = data->m_wasNpnNegotiated;
119    response->m_wasAlternateProtocolAvailable = data->m_wasAlternateProtocolAvailable;
120    response->m_wasFetchedViaProxy = data->m_wasFetchedViaProxy;
121    response->m_wasFetchedViaServiceWorker = data->m_wasFetchedViaServiceWorker;
122    response->m_responseTime = data->m_responseTime;
123    response->m_remoteIPAddress = AtomicString(data->m_remoteIPAddress);
124    response->m_remotePort = data->m_remotePort;
125    response->m_downloadedFilePath = data->m_downloadedFilePath;
126    response->m_downloadedFileHandle = data->m_downloadedFileHandle;
127
128    // Bug https://bugs.webkit.org/show_bug.cgi?id=60397 this doesn't support
129    // whatever values may be present in the opaque m_extraData structure.
130
131    return response.release();
132}
133
134PassOwnPtr<CrossThreadResourceResponseData> ResourceResponse::copyData() const
135{
136    OwnPtr<CrossThreadResourceResponseData> data = adoptPtr(new CrossThreadResourceResponseData);
137    data->m_url = url().copy();
138    data->m_mimeType = mimeType().string().isolatedCopy();
139    data->m_expectedContentLength = expectedContentLength();
140    data->m_textEncodingName = textEncodingName().string().isolatedCopy();
141    data->m_suggestedFilename = suggestedFilename().isolatedCopy();
142    data->m_httpStatusCode = httpStatusCode();
143    data->m_httpStatusText = httpStatusText().string().isolatedCopy();
144    data->m_httpHeaders = httpHeaderFields().copyData();
145    data->m_lastModifiedDate = lastModifiedDate();
146    if (m_resourceLoadTiming)
147        data->m_resourceLoadTiming = m_resourceLoadTiming->deepCopy();
148    data->m_securityInfo = CString(m_securityInfo.data(), m_securityInfo.length());
149    data->m_httpVersion = m_httpVersion;
150    data->m_appCacheID = m_appCacheID;
151    data->m_appCacheManifestURL = m_appCacheManifestURL.copy();
152    data->m_isMultipartPayload = m_isMultipartPayload;
153    data->m_wasFetchedViaSPDY = m_wasFetchedViaSPDY;
154    data->m_wasNpnNegotiated = m_wasNpnNegotiated;
155    data->m_wasAlternateProtocolAvailable = m_wasAlternateProtocolAvailable;
156    data->m_wasFetchedViaProxy = m_wasFetchedViaProxy;
157    data->m_wasFetchedViaServiceWorker = m_wasFetchedViaServiceWorker;
158    data->m_responseTime = m_responseTime;
159    data->m_remoteIPAddress = m_remoteIPAddress.string().isolatedCopy();
160    data->m_remotePort = m_remotePort;
161    data->m_downloadedFilePath = m_downloadedFilePath.isolatedCopy();
162    data->m_downloadedFileHandle = m_downloadedFileHandle;
163
164    // Bug https://bugs.webkit.org/show_bug.cgi?id=60397 this doesn't support
165    // whatever values may be present in the opaque m_extraData structure.
166
167    return data.release();
168}
169
170bool ResourceResponse::isHTTP() const
171{
172    return m_url.protocolIsInHTTPFamily();
173}
174
175const KURL& ResourceResponse::url() const
176{
177    return m_url;
178}
179
180void ResourceResponse::setURL(const KURL& url)
181{
182    m_isNull = false;
183
184    m_url = url;
185}
186
187const AtomicString& ResourceResponse::mimeType() const
188{
189    return m_mimeType;
190}
191
192void ResourceResponse::setMimeType(const AtomicString& mimeType)
193{
194    m_isNull = false;
195
196    // FIXME: MIME type is determined by HTTP Content-Type header. We should update the header, so that it doesn't disagree with m_mimeType.
197    m_mimeType = mimeType;
198}
199
200long long ResourceResponse::expectedContentLength() const
201{
202    return m_expectedContentLength;
203}
204
205void ResourceResponse::setExpectedContentLength(long long expectedContentLength)
206{
207    m_isNull = false;
208
209    // FIXME: Content length is determined by HTTP Content-Length header. We should update the header, so that it doesn't disagree with m_expectedContentLength.
210    m_expectedContentLength = expectedContentLength;
211}
212
213const AtomicString& ResourceResponse::textEncodingName() const
214{
215    return m_textEncodingName;
216}
217
218void ResourceResponse::setTextEncodingName(const AtomicString& encodingName)
219{
220    m_isNull = false;
221
222    // FIXME: Text encoding is determined by HTTP Content-Type header. We should update the header, so that it doesn't disagree with m_textEncodingName.
223    m_textEncodingName = encodingName;
224}
225
226// FIXME should compute this on the fly
227const String& ResourceResponse::suggestedFilename() const
228{
229    return m_suggestedFilename;
230}
231
232void ResourceResponse::setSuggestedFilename(const String& suggestedName)
233{
234    m_isNull = false;
235
236    // FIXME: Suggested file name is calculated based on other headers. There should not be a setter for it.
237    m_suggestedFilename = suggestedName;
238}
239
240int ResourceResponse::httpStatusCode() const
241{
242    return m_httpStatusCode;
243}
244
245void ResourceResponse::setHTTPStatusCode(int statusCode)
246{
247    m_httpStatusCode = statusCode;
248}
249
250const AtomicString& ResourceResponse::httpStatusText() const
251{
252    return m_httpStatusText;
253}
254
255void ResourceResponse::setHTTPStatusText(const AtomicString& statusText)
256{
257    m_httpStatusText = statusText;
258}
259
260const AtomicString& ResourceResponse::httpHeaderField(const AtomicString& name) const
261{
262    return m_httpHeaderFields.get(name);
263}
264
265const AtomicString& ResourceResponse::httpHeaderField(const char* name) const
266{
267    return m_httpHeaderFields.get(name);
268}
269
270static const AtomicString& cacheControlHeaderString()
271{
272    DEFINE_STATIC_LOCAL(const AtomicString, cacheControlHeader, ("cache-control", AtomicString::ConstructFromLiteral));
273    return cacheControlHeader;
274}
275
276static const AtomicString& pragmaHeaderString()
277{
278    DEFINE_STATIC_LOCAL(const AtomicString, pragmaHeader, ("pragma", AtomicString::ConstructFromLiteral));
279    return pragmaHeader;
280}
281
282void ResourceResponse::updateHeaderParsedState(const AtomicString& name)
283{
284    DEFINE_STATIC_LOCAL(const AtomicString, ageHeader, ("age", AtomicString::ConstructFromLiteral));
285    DEFINE_STATIC_LOCAL(const AtomicString, dateHeader, ("date", AtomicString::ConstructFromLiteral));
286    DEFINE_STATIC_LOCAL(const AtomicString, expiresHeader, ("expires", AtomicString::ConstructFromLiteral));
287    DEFINE_STATIC_LOCAL(const AtomicString, lastModifiedHeader, ("last-modified", AtomicString::ConstructFromLiteral));
288
289    if (equalIgnoringCase(name, ageHeader))
290        m_haveParsedAgeHeader = false;
291    else if (equalIgnoringCase(name, cacheControlHeaderString()) || equalIgnoringCase(name, pragmaHeaderString()))
292        m_cacheControlHeader = CacheControlHeader();
293    else if (equalIgnoringCase(name, dateHeader))
294        m_haveParsedDateHeader = false;
295    else if (equalIgnoringCase(name, expiresHeader))
296        m_haveParsedExpiresHeader = false;
297    else if (equalIgnoringCase(name, lastModifiedHeader))
298        m_haveParsedLastModifiedHeader = false;
299}
300
301void ResourceResponse::setHTTPHeaderField(const AtomicString& name, const AtomicString& value)
302{
303    updateHeaderParsedState(name);
304
305    m_httpHeaderFields.set(name, value);
306}
307
308void ResourceResponse::addHTTPHeaderField(const AtomicString& name, const AtomicString& value)
309{
310    updateHeaderParsedState(name);
311
312    HTTPHeaderMap::AddResult result = m_httpHeaderFields.add(name, value);
313    if (!result.isNewEntry)
314        result.storedValue->value = result.storedValue->value + ", " + value;
315}
316
317void ResourceResponse::clearHTTPHeaderField(const AtomicString& name)
318{
319    m_httpHeaderFields.remove(name);
320}
321
322const HTTPHeaderMap& ResourceResponse::httpHeaderFields() const
323{
324    return m_httpHeaderFields;
325}
326
327bool ResourceResponse::cacheControlContainsNoCache()
328{
329    if (!m_cacheControlHeader.parsed)
330        m_cacheControlHeader = parseCacheControlDirectives(m_httpHeaderFields.get(cacheControlHeaderString()), m_httpHeaderFields.get(pragmaHeaderString()));
331    return m_cacheControlHeader.containsNoCache;
332}
333
334bool ResourceResponse::cacheControlContainsNoStore()
335{
336    if (!m_cacheControlHeader.parsed)
337        m_cacheControlHeader = parseCacheControlDirectives(m_httpHeaderFields.get(cacheControlHeaderString()), m_httpHeaderFields.get(pragmaHeaderString()));
338    return m_cacheControlHeader.containsNoStore;
339}
340
341bool ResourceResponse::cacheControlContainsMustRevalidate()
342{
343    if (!m_cacheControlHeader.parsed)
344        m_cacheControlHeader = parseCacheControlDirectives(m_httpHeaderFields.get(cacheControlHeaderString()), m_httpHeaderFields.get(pragmaHeaderString()));
345    return m_cacheControlHeader.containsMustRevalidate;
346}
347
348bool ResourceResponse::hasCacheValidatorFields() const
349{
350    DEFINE_STATIC_LOCAL(const AtomicString, lastModifiedHeader, ("last-modified", AtomicString::ConstructFromLiteral));
351    DEFINE_STATIC_LOCAL(const AtomicString, eTagHeader, ("etag", AtomicString::ConstructFromLiteral));
352    return !m_httpHeaderFields.get(lastModifiedHeader).isEmpty() || !m_httpHeaderFields.get(eTagHeader).isEmpty();
353}
354
355double ResourceResponse::cacheControlMaxAge()
356{
357    if (!m_cacheControlHeader.parsed)
358        m_cacheControlHeader = parseCacheControlDirectives(m_httpHeaderFields.get(cacheControlHeaderString()), m_httpHeaderFields.get(pragmaHeaderString()));
359    return m_cacheControlHeader.maxAge;
360}
361
362static double parseDateValueInHeader(const HTTPHeaderMap& headers, const AtomicString& headerName)
363{
364    const AtomicString& headerValue = headers.get(headerName);
365    if (headerValue.isEmpty())
366        return std::numeric_limits<double>::quiet_NaN();
367    // This handles all date formats required by RFC2616:
368    // Sun, 06 Nov 1994 08:49:37 GMT  ; RFC 822, updated by RFC 1123
369    // Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
370    // Sun Nov  6 08:49:37 1994       ; ANSI C's asctime() format
371    double dateInMilliseconds = parseDate(headerValue);
372    if (!std::isfinite(dateInMilliseconds))
373        return std::numeric_limits<double>::quiet_NaN();
374    return dateInMilliseconds / 1000;
375}
376
377double ResourceResponse::date() const
378{
379    if (!m_haveParsedDateHeader) {
380        DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("date", AtomicString::ConstructFromLiteral));
381        m_date = parseDateValueInHeader(m_httpHeaderFields, headerName);
382        m_haveParsedDateHeader = true;
383    }
384    return m_date;
385}
386
387double ResourceResponse::age() const
388{
389    if (!m_haveParsedAgeHeader) {
390        DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("age", AtomicString::ConstructFromLiteral));
391        const AtomicString& headerValue = m_httpHeaderFields.get(headerName);
392        bool ok;
393        m_age = headerValue.toDouble(&ok);
394        if (!ok)
395            m_age = std::numeric_limits<double>::quiet_NaN();
396        m_haveParsedAgeHeader = true;
397    }
398    return m_age;
399}
400
401double ResourceResponse::expires() const
402{
403    if (!m_haveParsedExpiresHeader) {
404        DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("expires", AtomicString::ConstructFromLiteral));
405        m_expires = parseDateValueInHeader(m_httpHeaderFields, headerName);
406        m_haveParsedExpiresHeader = true;
407    }
408    return m_expires;
409}
410
411double ResourceResponse::lastModified() const
412{
413    if (!m_haveParsedLastModifiedHeader) {
414        DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("last-modified", AtomicString::ConstructFromLiteral));
415        m_lastModified = parseDateValueInHeader(m_httpHeaderFields, headerName);
416        m_haveParsedLastModifiedHeader = true;
417    }
418    return m_lastModified;
419}
420
421bool ResourceResponse::isAttachment() const
422{
423    DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("content-disposition", AtomicString::ConstructFromLiteral));
424    String value = m_httpHeaderFields.get(headerName);
425    size_t loc = value.find(';');
426    if (loc != kNotFound)
427        value = value.left(loc);
428    value = value.stripWhiteSpace();
429    DEFINE_STATIC_LOCAL(const AtomicString, attachmentString, ("attachment", AtomicString::ConstructFromLiteral));
430    return equalIgnoringCase(value, attachmentString);
431}
432
433void ResourceResponse::setLastModifiedDate(time_t lastModifiedDate)
434{
435    m_lastModifiedDate = lastModifiedDate;
436}
437
438time_t ResourceResponse::lastModifiedDate() const
439{
440    return m_lastModifiedDate;
441}
442
443bool ResourceResponse::wasCached() const
444{
445    return m_wasCached;
446}
447
448void ResourceResponse::setWasCached(bool value)
449{
450    m_wasCached = value;
451}
452
453bool ResourceResponse::connectionReused() const
454{
455    return m_connectionReused;
456}
457
458void ResourceResponse::setConnectionReused(bool connectionReused)
459{
460    m_connectionReused = connectionReused;
461}
462
463unsigned ResourceResponse::connectionID() const
464{
465    return m_connectionID;
466}
467
468void ResourceResponse::setConnectionID(unsigned connectionID)
469{
470    m_connectionID = connectionID;
471}
472
473ResourceLoadTiming* ResourceResponse::resourceLoadTiming() const
474{
475    return m_resourceLoadTiming.get();
476}
477
478void ResourceResponse::setResourceLoadTiming(PassRefPtr<ResourceLoadTiming> resourceLoadTiming)
479{
480    m_resourceLoadTiming = resourceLoadTiming;
481}
482
483PassRefPtr<ResourceLoadInfo> ResourceResponse::resourceLoadInfo() const
484{
485    return m_resourceLoadInfo.get();
486}
487
488void ResourceResponse::setResourceLoadInfo(PassRefPtr<ResourceLoadInfo> loadInfo)
489{
490    m_resourceLoadInfo = loadInfo;
491}
492
493void ResourceResponse::setDownloadedFilePath(const String& downloadedFilePath)
494{
495    m_downloadedFilePath = downloadedFilePath;
496    if (m_downloadedFilePath.isEmpty()) {
497        m_downloadedFileHandle.clear();
498        return;
499    }
500    OwnPtr<BlobData> blobData = BlobData::create();
501    blobData->appendFile(m_downloadedFilePath);
502    blobData->detachFromCurrentThread();
503    m_downloadedFileHandle = BlobDataHandle::create(blobData.release(), -1);
504}
505
506bool ResourceResponse::compare(const ResourceResponse& a, const ResourceResponse& b)
507{
508    if (a.isNull() != b.isNull())
509        return false;
510    if (a.url() != b.url())
511        return false;
512    if (a.mimeType() != b.mimeType())
513        return false;
514    if (a.expectedContentLength() != b.expectedContentLength())
515        return false;
516    if (a.textEncodingName() != b.textEncodingName())
517        return false;
518    if (a.suggestedFilename() != b.suggestedFilename())
519        return false;
520    if (a.httpStatusCode() != b.httpStatusCode())
521        return false;
522    if (a.httpStatusText() != b.httpStatusText())
523        return false;
524    if (a.httpHeaderFields() != b.httpHeaderFields())
525        return false;
526    if (a.resourceLoadTiming() && b.resourceLoadTiming() && *a.resourceLoadTiming() == *b.resourceLoadTiming())
527        return true;
528    if (a.resourceLoadTiming() != b.resourceLoadTiming())
529        return false;
530    return true;
531}
532
533}
534