Home | History | Annotate | Download | only in network 
      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 
     36 using namespace std;
     37 
     38 namespace WebCore {
     39 
     40 static void parseCacheHeader(const String& header, Vector<pair<String, String> >& result);
     41 
     42 ResourceResponseBase::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 
     63 ResourceResponseBase::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 
     88 auto_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 
    107 auto_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 
    122 bool ResourceResponseBase::isHTTP() const
    123 {
    124     lazyInit();
    125 
    126     String protocol = m_url.protocol();
    127 
    128     return equalIgnoringCase(protocol, "http")  || equalIgnoringCase(protocol, "https");
    129 }
    130 
    131 const KURL& ResourceResponseBase::url() const
    132 {
    133     lazyInit();
    134 
    135     return m_url;
    136 }
    137 
    138 void ResourceResponseBase::setURL(const KURL& url)
    139 {
    140     lazyInit();
    141     m_isNull = false;
    142 
    143     m_url = url;
    144 }
    145 
    146 const String& ResourceResponseBase::mimeType() const
    147 {
    148     lazyInit();
    149 
    150     return m_mimeType;
    151 }
    152 
    153 void ResourceResponseBase::setMimeType(const String& mimeType)
    154 {
    155     lazyInit();
    156     m_isNull = false;
    157 
    158     m_mimeType = mimeType;
    159 }
    160 
    161 long long ResourceResponseBase::expectedContentLength() const
    162 {
    163     lazyInit();
    164 
    165     return m_expectedContentLength;
    166 }
    167 
    168 void ResourceResponseBase::setExpectedContentLength(long long expectedContentLength)
    169 {
    170     lazyInit();
    171     m_isNull = false;
    172 
    173     m_expectedContentLength = expectedContentLength;
    174 }
    175 
    176 const String& ResourceResponseBase::textEncodingName() const
    177 {
    178     lazyInit();
    179 
    180     return m_textEncodingName;
    181 }
    182 
    183 void 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
    192 const String& ResourceResponseBase::suggestedFilename() const
    193 {
    194     lazyInit();
    195 
    196     return m_suggestedFilename;
    197 }
    198 
    199 void ResourceResponseBase::setSuggestedFilename(const String& suggestedName)
    200 {
    201     lazyInit();
    202     m_isNull = false;
    203 
    204     m_suggestedFilename = suggestedName;
    205 }
    206 
    207 int ResourceResponseBase::httpStatusCode() const
    208 {
    209     lazyInit();
    210 
    211     return m_httpStatusCode;
    212 }
    213 
    214 void ResourceResponseBase::setHTTPStatusCode(int statusCode)
    215 {
    216     lazyInit();
    217 
    218     m_httpStatusCode = statusCode;
    219 }
    220 
    221 const String& ResourceResponseBase::httpStatusText() const
    222 {
    223     lazyInit();
    224 
    225     return m_httpStatusText;
    226 }
    227 
    228 void ResourceResponseBase::setHTTPStatusText(const String& statusText)
    229 {
    230     lazyInit();
    231 
    232     m_httpStatusText = statusText;
    233 }
    234 
    235 String ResourceResponseBase::httpHeaderField(const AtomicString& name) const
    236 {
    237     lazyInit();
    238 
    239     return m_httpHeaderFields.get(name);
    240 }
    241 
    242 String ResourceResponseBase::httpHeaderField(const char* name) const
    243 {
    244     lazyInit();
    245 
    246     return m_httpHeaderFields.get(name);
    247 }
    248 
    249 void 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 
    273 const HTTPHeaderMap& ResourceResponseBase::httpHeaderFields() const
    274 {
    275     lazyInit();
    276 
    277     return m_httpHeaderFields;
    278 }
    279 
    280 void 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 
    332 bool ResourceResponseBase::cacheControlContainsNoCache() const
    333 {
    334     if (!m_haveParsedCacheControlHeader)
    335         parseCacheControlDirectives();
    336     return m_cacheControlContainsNoCache;
    337 }
    338 
    339 bool ResourceResponseBase::cacheControlContainsNoStore() const
    340 {
    341     if (!m_haveParsedCacheControlHeader)
    342         parseCacheControlDirectives();
    343     return m_cacheControlContainsNoStore;
    344 }
    345 
    346 bool ResourceResponseBase::cacheControlContainsMustRevalidate() const
    347 {
    348     if (!m_haveParsedCacheControlHeader)
    349         parseCacheControlDirectives();
    350     return m_cacheControlContainsMustRevalidate;
    351 }
    352 
    353 double ResourceResponseBase::cacheControlMaxAge() const
    354 {
    355     if (!m_haveParsedCacheControlHeader)
    356         parseCacheControlDirectives();
    357     return m_cacheControlMaxAge;
    358 }
    359 
    360 static 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 
    375 double 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 
    387 double 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 
    403 double 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 
    415 double 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 
    427 bool 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 
    441 void ResourceResponseBase::setLastModifiedDate(time_t lastModifiedDate)
    442 {
    443     lazyInit();
    444 
    445     m_lastModifiedDate = lastModifiedDate;
    446 }
    447 
    448 time_t ResourceResponseBase::lastModifiedDate() const
    449 {
    450     lazyInit();
    451 
    452     return m_lastModifiedDate;
    453 }
    454 
    455 void ResourceResponseBase::lazyInit() const
    456 {
    457     const_cast<ResourceResponse*>(static_cast<const ResourceResponse*>(this))->platformLazyInit();
    458 }
    459 
    460 bool 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 
    483 static 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 
    512 static bool isControlCharacter(UChar c)
    513 {
    514     return c < ' ' || c == 127;
    515 }
    516 
    517 static inline String trimToNextSeparator(const String& str)
    518 {
    519     return str.substring(0, str.find(isCacheHeaderSeparator, 0));
    520 }
    521 
    522 static 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