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 "ResourceResponseBase.h"
29
30#include "HTTPParsers.h"
31#include "ResourceResponse.h"
32#include <wtf/CurrentTime.h>
33#include <wtf/MathExtras.h>
34#include <wtf/StdLibExtras.h>
35
36using namespace std;
37
38namespace WebCore {
39
40static void parseCacheHeader(const String& header, Vector<pair<String, String> >& result);
41
42ResourceResponseBase::ResourceResponseBase()
43    : m_expectedContentLength(0)
44    , m_httpStatusCode(0)
45    , m_lastModifiedDate(0)
46    , m_isNull(true)
47    , m_haveParsedCacheControlHeader(false)
48    , m_haveParsedAgeHeader(false)
49    , m_haveParsedDateHeader(false)
50    , m_haveParsedExpiresHeader(false)
51    , m_haveParsedLastModifiedHeader(false)
52    , m_cacheControlContainsNoCache(false)
53    , m_cacheControlContainsNoStore(false)
54    , m_cacheControlContainsMustRevalidate(false)
55    , m_cacheControlMaxAge(0.0)
56    , m_age(0.0)
57    , m_date(0.0)
58    , m_expires(0.0)
59    , m_lastModified(0.0)
60{
61}
62
63ResourceResponseBase::ResourceResponseBase(const KURL& url, const String& mimeType, long long expectedLength, const String& textEncodingName, const String& filename)
64    : m_url(url)
65    , m_mimeType(mimeType)
66    , m_expectedContentLength(expectedLength)
67    , m_textEncodingName(textEncodingName)
68    , m_suggestedFilename(filename)
69    , m_httpStatusCode(0)
70    , m_lastModifiedDate(0)
71    , m_isNull(false)
72    , m_haveParsedCacheControlHeader(false)
73    , m_haveParsedAgeHeader(false)
74    , m_haveParsedDateHeader(false)
75    , m_haveParsedExpiresHeader(false)
76    , m_haveParsedLastModifiedHeader(false)
77    , m_cacheControlContainsNoCache(false)
78    , m_cacheControlContainsNoStore(false)
79    , m_cacheControlContainsMustRevalidate(false)
80    , m_cacheControlMaxAge(0.0)
81    , m_age(0.0)
82    , m_date(0.0)
83    , m_expires(0.0)
84    , m_lastModified(0.0)
85{
86}
87
88auto_ptr<ResourceResponse> ResourceResponseBase::adopt(auto_ptr<CrossThreadResourceResponseData> data)
89{
90    auto_ptr<ResourceResponse> response(new ResourceResponse());
91    response->setURL(data->m_url);
92    response->setMimeType(data->m_mimeType);
93    response->setExpectedContentLength(data->m_expectedContentLength);
94    response->setTextEncodingName(data->m_textEncodingName);
95    response->setSuggestedFilename(data->m_suggestedFilename);
96
97    response->setHTTPStatusCode(data->m_httpStatusCode);
98    response->setHTTPStatusText(data->m_httpStatusText);
99
100    response->lazyInit();
101    response->m_httpHeaderFields.adopt(std::auto_ptr<CrossThreadHTTPHeaderMapData>(data->m_httpHeaders.release()));
102    response->setLastModifiedDate(data->m_lastModifiedDate);
103
104    return response;
105}
106
107auto_ptr<CrossThreadResourceResponseData> ResourceResponseBase::copyData() const
108{
109    auto_ptr<CrossThreadResourceResponseData> data(new CrossThreadResourceResponseData());
110    data->m_url = url().copy();
111    data->m_mimeType = mimeType().crossThreadString();
112    data->m_expectedContentLength = expectedContentLength();
113    data->m_textEncodingName = textEncodingName().crossThreadString();
114    data->m_suggestedFilename = suggestedFilename().crossThreadString();
115    data->m_httpStatusCode = httpStatusCode();
116    data->m_httpStatusText = httpStatusText().crossThreadString();
117    data->m_httpHeaders.adopt(httpHeaderFields().copyData());
118    data->m_lastModifiedDate = lastModifiedDate();
119    return data;
120}
121
122bool ResourceResponseBase::isHTTP() const
123{
124    lazyInit();
125
126    String protocol = m_url.protocol();
127
128    return equalIgnoringCase(protocol, "http")  || equalIgnoringCase(protocol, "https");
129}
130
131const KURL& ResourceResponseBase::url() const
132{
133    lazyInit();
134
135    return m_url;
136}
137
138void ResourceResponseBase::setURL(const KURL& url)
139{
140    lazyInit();
141    m_isNull = false;
142
143    m_url = url;
144}
145
146const String& ResourceResponseBase::mimeType() const
147{
148    lazyInit();
149
150    return m_mimeType;
151}
152
153void ResourceResponseBase::setMimeType(const String& mimeType)
154{
155    lazyInit();
156    m_isNull = false;
157
158    m_mimeType = mimeType;
159}
160
161long long ResourceResponseBase::expectedContentLength() const
162{
163    lazyInit();
164
165    return m_expectedContentLength;
166}
167
168void ResourceResponseBase::setExpectedContentLength(long long expectedContentLength)
169{
170    lazyInit();
171    m_isNull = false;
172
173    m_expectedContentLength = expectedContentLength;
174}
175
176const String& ResourceResponseBase::textEncodingName() const
177{
178    lazyInit();
179
180    return m_textEncodingName;
181}
182
183void ResourceResponseBase::setTextEncodingName(const String& encodingName)
184{
185    lazyInit();
186    m_isNull = false;
187
188    m_textEncodingName = encodingName;
189}
190
191// FIXME should compute this on the fly
192const String& ResourceResponseBase::suggestedFilename() const
193{
194    lazyInit();
195
196    return m_suggestedFilename;
197}
198
199void ResourceResponseBase::setSuggestedFilename(const String& suggestedName)
200{
201    lazyInit();
202    m_isNull = false;
203
204    m_suggestedFilename = suggestedName;
205}
206
207int ResourceResponseBase::httpStatusCode() const
208{
209    lazyInit();
210
211    return m_httpStatusCode;
212}
213
214void ResourceResponseBase::setHTTPStatusCode(int statusCode)
215{
216    lazyInit();
217
218    m_httpStatusCode = statusCode;
219}
220
221const String& ResourceResponseBase::httpStatusText() const
222{
223    lazyInit();
224
225    return m_httpStatusText;
226}
227
228void ResourceResponseBase::setHTTPStatusText(const String& statusText)
229{
230    lazyInit();
231
232    m_httpStatusText = statusText;
233}
234
235String ResourceResponseBase::httpHeaderField(const AtomicString& name) const
236{
237    lazyInit();
238
239    return m_httpHeaderFields.get(name);
240}
241
242String ResourceResponseBase::httpHeaderField(const char* name) const
243{
244    lazyInit();
245
246    return m_httpHeaderFields.get(name);
247}
248
249void ResourceResponseBase::setHTTPHeaderField(const AtomicString& name, const String& value)
250{
251    lazyInit();
252
253    DEFINE_STATIC_LOCAL(const AtomicString, ageHeader, ("age"));
254    DEFINE_STATIC_LOCAL(const AtomicString, cacheControlHeader, ("cache-control"));
255    DEFINE_STATIC_LOCAL(const AtomicString, dateHeader, ("date"));
256    DEFINE_STATIC_LOCAL(const AtomicString, expiresHeader, ("expires"));
257    DEFINE_STATIC_LOCAL(const AtomicString, lastModifiedHeader, ("last-modified"));
258    DEFINE_STATIC_LOCAL(const AtomicString, pragmaHeader, ("pragma"));
259    if (equalIgnoringCase(name, ageHeader))
260        m_haveParsedAgeHeader = false;
261    else if (equalIgnoringCase(name, cacheControlHeader) || equalIgnoringCase(name, pragmaHeader))
262        m_haveParsedCacheControlHeader = false;
263    else if (equalIgnoringCase(name, dateHeader))
264        m_haveParsedDateHeader = false;
265    else if (equalIgnoringCase(name, expiresHeader))
266        m_haveParsedExpiresHeader = false;
267    else if (equalIgnoringCase(name, lastModifiedHeader))
268        m_haveParsedLastModifiedHeader = false;
269
270    m_httpHeaderFields.set(name, value);
271}
272
273const HTTPHeaderMap& ResourceResponseBase::httpHeaderFields() const
274{
275    lazyInit();
276
277    return m_httpHeaderFields;
278}
279
280void ResourceResponseBase::parseCacheControlDirectives() const
281{
282    ASSERT(!m_haveParsedCacheControlHeader);
283
284    lazyInit();
285
286    m_haveParsedCacheControlHeader = true;
287
288    m_cacheControlContainsMustRevalidate = false;
289    m_cacheControlContainsNoCache = false;
290    m_cacheControlMaxAge = numeric_limits<double>::quiet_NaN();
291
292    DEFINE_STATIC_LOCAL(const AtomicString, cacheControlString, ("cache-control"));
293    DEFINE_STATIC_LOCAL(const AtomicString, noCacheDirective, ("no-cache"));
294    DEFINE_STATIC_LOCAL(const AtomicString, noStoreDirective, ("no-store"));
295    DEFINE_STATIC_LOCAL(const AtomicString, mustRevalidateDirective, ("must-revalidate"));
296    DEFINE_STATIC_LOCAL(const AtomicString, maxAgeDirective, ("max-age"));
297
298    String cacheControlValue = m_httpHeaderFields.get(cacheControlString);
299    if (!cacheControlValue.isEmpty()) {
300        Vector<pair<String, String> > directives;
301        parseCacheHeader(cacheControlValue, directives);
302
303        size_t directivesSize = directives.size();
304        for (size_t i = 0; i < directivesSize; ++i) {
305            // RFC2616 14.9.1: A no-cache directive with a value is only meaningful for proxy caches.
306            // It should be ignored by a browser level cache.
307            if (equalIgnoringCase(directives[i].first, noCacheDirective) && directives[i].second.isEmpty())
308                m_cacheControlContainsNoCache = true;
309            else if (equalIgnoringCase(directives[i].first, noStoreDirective))
310                m_cacheControlContainsNoStore = true;
311            else if (equalIgnoringCase(directives[i].first, mustRevalidateDirective))
312                m_cacheControlContainsMustRevalidate = true;
313            else if (equalIgnoringCase(directives[i].first, maxAgeDirective)) {
314                bool ok;
315                double maxAge = directives[i].second.toDouble(&ok);
316                if (ok)
317                    m_cacheControlMaxAge = maxAge;
318            }
319        }
320    }
321
322    if (!m_cacheControlContainsNoCache) {
323        // Handle Pragma: no-cache
324        // This is deprecated and equivalent to Cache-control: no-cache
325        // Don't bother tokenizing the value, it is not important
326        DEFINE_STATIC_LOCAL(const AtomicString, pragmaHeader, ("pragma"));
327        String pragmaValue = m_httpHeaderFields.get(pragmaHeader);
328        m_cacheControlContainsNoCache = pragmaValue.lower().contains(noCacheDirective);
329    }
330}
331
332bool ResourceResponseBase::cacheControlContainsNoCache() const
333{
334    if (!m_haveParsedCacheControlHeader)
335        parseCacheControlDirectives();
336    return m_cacheControlContainsNoCache;
337}
338
339bool ResourceResponseBase::cacheControlContainsNoStore() const
340{
341    if (!m_haveParsedCacheControlHeader)
342        parseCacheControlDirectives();
343    return m_cacheControlContainsNoStore;
344}
345
346bool ResourceResponseBase::cacheControlContainsMustRevalidate() const
347{
348    if (!m_haveParsedCacheControlHeader)
349        parseCacheControlDirectives();
350    return m_cacheControlContainsMustRevalidate;
351}
352
353double ResourceResponseBase::cacheControlMaxAge() const
354{
355    if (!m_haveParsedCacheControlHeader)
356        parseCacheControlDirectives();
357    return m_cacheControlMaxAge;
358}
359
360static double parseDateValueInHeader(const HTTPHeaderMap& headers, const AtomicString& headerName)
361{
362    String headerValue = headers.get(headerName);
363    if (headerValue.isEmpty())
364        return std::numeric_limits<double>::quiet_NaN();
365    // This handles all date formats required by RFC2616:
366    // Sun, 06 Nov 1994 08:49:37 GMT  ; RFC 822, updated by RFC 1123
367    // Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
368    // Sun Nov  6 08:49:37 1994       ; ANSI C's asctime() format
369    double dateInMilliseconds = parseDate(headerValue);
370    if (!isfinite(dateInMilliseconds))
371        return std::numeric_limits<double>::quiet_NaN();
372    return dateInMilliseconds / 1000;
373}
374
375double ResourceResponseBase::date() const
376{
377    lazyInit();
378
379    if (!m_haveParsedDateHeader) {
380        DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("date"));
381        m_date = parseDateValueInHeader(m_httpHeaderFields, headerName);
382        m_haveParsedDateHeader = true;
383    }
384    return m_date;
385}
386
387double ResourceResponseBase::age() const
388{
389    lazyInit();
390
391    if (!m_haveParsedAgeHeader) {
392        DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("age"));
393        String headerValue = m_httpHeaderFields.get(headerName);
394        bool ok;
395        m_age = headerValue.toDouble(&ok);
396        if (!ok)
397            m_age = std::numeric_limits<double>::quiet_NaN();
398        m_haveParsedAgeHeader = true;
399    }
400    return m_age;
401}
402
403double ResourceResponseBase::expires() const
404{
405    lazyInit();
406
407    if (!m_haveParsedExpiresHeader) {
408        DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("expires"));
409        m_expires = parseDateValueInHeader(m_httpHeaderFields, headerName);
410        m_haveParsedExpiresHeader = true;
411    }
412    return m_expires;
413}
414
415double ResourceResponseBase::lastModified() const
416{
417    lazyInit();
418
419    if (!m_haveParsedLastModifiedHeader) {
420        DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("last-modified"));
421        m_lastModified = parseDateValueInHeader(m_httpHeaderFields, headerName);
422        m_haveParsedLastModifiedHeader = true;
423    }
424    return m_lastModified;
425}
426
427bool ResourceResponseBase::isAttachment() const
428{
429    lazyInit();
430
431    DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("content-disposition"));
432    String value = m_httpHeaderFields.get(headerName);
433    int loc = value.find(';');
434    if (loc != -1)
435        value = value.left(loc);
436    value = value.stripWhiteSpace();
437    DEFINE_STATIC_LOCAL(const AtomicString, attachmentString, ("attachment"));
438    return equalIgnoringCase(value, attachmentString);
439}
440
441void ResourceResponseBase::setLastModifiedDate(time_t lastModifiedDate)
442{
443    lazyInit();
444
445    m_lastModifiedDate = lastModifiedDate;
446}
447
448time_t ResourceResponseBase::lastModifiedDate() const
449{
450    lazyInit();
451
452    return m_lastModifiedDate;
453}
454
455void ResourceResponseBase::lazyInit() const
456{
457    const_cast<ResourceResponse*>(static_cast<const ResourceResponse*>(this))->platformLazyInit();
458}
459
460bool ResourceResponseBase::compare(const ResourceResponse& a, const ResourceResponse& b)
461{
462    if (a.isNull() != b.isNull())
463        return false;
464    if (a.url() != b.url())
465        return false;
466    if (a.mimeType() != b.mimeType())
467        return false;
468    if (a.expectedContentLength() != b.expectedContentLength())
469        return false;
470    if (a.textEncodingName() != b.textEncodingName())
471        return false;
472    if (a.suggestedFilename() != b.suggestedFilename())
473        return false;
474    if (a.httpStatusCode() != b.httpStatusCode())
475        return false;
476    if (a.httpStatusText() != b.httpStatusText())
477        return false;
478    if (a.httpHeaderFields() != b.httpHeaderFields())
479        return false;
480    return ResourceResponse::platformCompare(a, b);
481}
482
483static bool isCacheHeaderSeparator(UChar c)
484{
485    // See RFC 2616, Section 2.2
486    switch (c) {
487        case '(':
488        case ')':
489        case '<':
490        case '>':
491        case '@':
492        case ',':
493        case ';':
494        case ':':
495        case '\\':
496        case '"':
497        case '/':
498        case '[':
499        case ']':
500        case '?':
501        case '=':
502        case '{':
503        case '}':
504        case ' ':
505        case '\t':
506            return true;
507        default:
508            return false;
509    }
510}
511
512static bool isControlCharacter(UChar c)
513{
514    return c < ' ' || c == 127;
515}
516
517static inline String trimToNextSeparator(const String& str)
518{
519    return str.substring(0, str.find(isCacheHeaderSeparator, 0));
520}
521
522static void parseCacheHeader(const String& header, Vector<pair<String, String> >& result)
523{
524    const String safeHeader = header.removeCharacters(isControlCharacter);
525    unsigned max = safeHeader.length();
526    for (unsigned pos = 0; pos < max; /* pos incremented in loop */) {
527        int nextCommaPosition = safeHeader.find(',', pos);
528        int nextEqualSignPosition = safeHeader.find('=', pos);
529        if (nextEqualSignPosition >= 0 && (nextEqualSignPosition < nextCommaPosition || nextCommaPosition < 0)) {
530            // Get directive name, parse right hand side of equal sign, then add to map
531            String directive = trimToNextSeparator(safeHeader.substring(pos, nextEqualSignPosition - pos).stripWhiteSpace());
532            pos += nextEqualSignPosition - pos + 1;
533
534            String value = safeHeader.substring(pos, max - pos).stripWhiteSpace();
535            if (value[0] == '"') {
536                // The value is a quoted string
537                int nextDoubleQuotePosition = value.find('"', 1);
538                if (nextDoubleQuotePosition >= 0) {
539                    // Store the value as a quoted string without quotes
540                    result.append(pair<String, String>(directive, value.substring(1, nextDoubleQuotePosition - 1).stripWhiteSpace()));
541                    pos += (safeHeader.find('"', pos) - pos) + nextDoubleQuotePosition + 1;
542                    // Move past next comma, if there is one
543                    int nextCommaPosition2 = safeHeader.find(',', pos);
544                    if (nextCommaPosition2 >= 0)
545                        pos += nextCommaPosition2 - pos + 1;
546                    else
547                        return; // Parse error if there is anything left with no comma
548                } else {
549                    // Parse error; just use the rest as the value
550                    result.append(pair<String, String>(directive, trimToNextSeparator(value.substring(1, value.length() - 1).stripWhiteSpace())));
551                    return;
552                }
553            } else {
554                // The value is a token until the next comma
555                int nextCommaPosition2 = value.find(',', 0);
556                if (nextCommaPosition2 >= 0) {
557                    // The value is delimited by the next comma
558                    result.append(pair<String, String>(directive, trimToNextSeparator(value.substring(0, nextCommaPosition2).stripWhiteSpace())));
559                    pos += (safeHeader.find(',', pos) - pos) + 1;
560                } else {
561                    // The rest is the value; no change to value needed
562                    result.append(pair<String, String>(directive, trimToNextSeparator(value)));
563                    return;
564                }
565            }
566        } else if (nextCommaPosition >= 0 && (nextCommaPosition < nextEqualSignPosition || nextEqualSignPosition < 0)) {
567            // Add directive to map with empty string as value
568            result.append(pair<String, String>(trimToNextSeparator(safeHeader.substring(pos, nextCommaPosition - pos).stripWhiteSpace()), ""));
569            pos += nextCommaPosition - pos + 1;
570        } else {
571            // Add last directive to map with empty string as value
572            result.append(pair<String, String>(trimToNextSeparator(safeHeader.substring(pos, max - pos).stripWhiteSpace()), ""));
573            return;
574        }
575    }
576}
577
578}
579