michael@0: /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
michael@0: /* vim:set ts=4 sw=4 sts=4 et cin: */
michael@0: /* This Source Code Form is subject to the terms of the Mozilla Public
michael@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0:  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
michael@0: 
michael@0: // HttpLog.h should generally be included first
michael@0: #include "HttpLog.h"
michael@0: 
michael@0: #include "nsHttpResponseHead.h"
michael@0: #include "nsPrintfCString.h"
michael@0: #include "prtime.h"
michael@0: #include "nsURLHelper.h"
michael@0: #include <algorithm>
michael@0: 
michael@0: namespace mozilla {
michael@0: namespace net {
michael@0: 
michael@0: //-----------------------------------------------------------------------------
michael@0: // nsHttpResponseHead <public>
michael@0: //-----------------------------------------------------------------------------
michael@0: 
michael@0: nsresult
michael@0: nsHttpResponseHead::SetHeader(nsHttpAtom hdr,
michael@0:                               const nsACString &val,
michael@0:                               bool merge)
michael@0: {
michael@0:     nsresult rv = mHeaders.SetHeader(hdr, val, merge);
michael@0:     if (NS_FAILED(rv)) return rv;
michael@0: 
michael@0:     // respond to changes in these headers.  we need to reparse the entire
michael@0:     // header since the change may have merged in additional values.
michael@0:     if (hdr == nsHttp::Cache_Control)
michael@0:         ParseCacheControl(mHeaders.PeekHeader(hdr));
michael@0:     else if (hdr == nsHttp::Pragma)
michael@0:         ParsePragma(mHeaders.PeekHeader(hdr));
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsHttpResponseHead::SetContentLength(int64_t len)
michael@0: {
michael@0:     mContentLength = len;
michael@0:     if (len < 0)
michael@0:         mHeaders.ClearHeader(nsHttp::Content_Length);
michael@0:     else
michael@0:         mHeaders.SetHeader(nsHttp::Content_Length, nsPrintfCString("%lld", len));
michael@0: }
michael@0: 
michael@0: void
michael@0: nsHttpResponseHead::Flatten(nsACString &buf, bool pruneTransients)
michael@0: {
michael@0:     if (mVersion == NS_HTTP_VERSION_0_9)
michael@0:         return;
michael@0: 
michael@0:     buf.AppendLiteral("HTTP/");
michael@0:     if (mVersion == NS_HTTP_VERSION_2_0)
michael@0:         buf.AppendLiteral("2.0 ");
michael@0:     else if (mVersion == NS_HTTP_VERSION_1_1)
michael@0:         buf.AppendLiteral("1.1 ");
michael@0:     else
michael@0:         buf.AppendLiteral("1.0 ");
michael@0: 
michael@0:     buf.Append(nsPrintfCString("%u", unsigned(mStatus)) +
michael@0:                NS_LITERAL_CSTRING(" ") +
michael@0:                mStatusText +
michael@0:                NS_LITERAL_CSTRING("\r\n"));
michael@0: 
michael@0:     if (!pruneTransients) {
michael@0:         mHeaders.Flatten(buf, false);
michael@0:         return;
michael@0:     }
michael@0: 
michael@0:     // otherwise, we need to iterate over the headers and only flatten
michael@0:     // those that are appropriate.
michael@0:     uint32_t i, count = mHeaders.Count();
michael@0:     for (i=0; i<count; ++i) {
michael@0:         nsHttpAtom header;
michael@0:         const char *value = mHeaders.PeekHeaderAt(i, header);
michael@0: 
michael@0:         if (!value || header == nsHttp::Connection
michael@0:                    || header == nsHttp::Proxy_Connection
michael@0:                    || header == nsHttp::Keep_Alive
michael@0:                    || header == nsHttp::WWW_Authenticate
michael@0:                    || header == nsHttp::Proxy_Authenticate
michael@0:                    || header == nsHttp::Trailer
michael@0:                    || header == nsHttp::Transfer_Encoding
michael@0:                    || header == nsHttp::Upgrade
michael@0:                    // XXX this will cause problems when we start honoring
michael@0:                    // Cache-Control: no-cache="set-cookie", what to do?
michael@0:                    || header == nsHttp::Set_Cookie)
michael@0:             continue;
michael@0: 
michael@0:         // otherwise, write out the "header: value\r\n" line
michael@0:         buf.Append(nsDependentCString(header.get()) +
michael@0:                    NS_LITERAL_CSTRING(": ") +
michael@0:                    nsDependentCString(value) +
michael@0:                    NS_LITERAL_CSTRING("\r\n"));
michael@0:     }
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsHttpResponseHead::Parse(char *block)
michael@0: {
michael@0: 
michael@0:     LOG(("nsHttpResponseHead::Parse [this=%p]\n", this));
michael@0: 
michael@0:     // this command works on a buffer as prepared by Flatten, as such it is
michael@0:     // not very forgiving ;-)
michael@0: 
michael@0:     char *p = PL_strstr(block, "\r\n");
michael@0:     if (!p)
michael@0:         return NS_ERROR_UNEXPECTED;
michael@0: 
michael@0:     *p = 0;
michael@0:     ParseStatusLine(block);
michael@0: 
michael@0:     do {
michael@0:         block = p + 2;
michael@0: 
michael@0: 		if (*block == 0)
michael@0: 			break;
michael@0: 
michael@0:         p = PL_strstr(block, "\r\n");
michael@0:         if (!p)
michael@0:             return NS_ERROR_UNEXPECTED;
michael@0: 
michael@0:         *p = 0;
michael@0:         ParseHeaderLine(block);
michael@0: 
michael@0:     } while (1);
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsHttpResponseHead::AssignDefaultStatusText()
michael@0: {
michael@0:     LOG(("response status line needs default reason phrase\n"));
michael@0: 
michael@0:     // if a http response doesn't contain a reason phrase, put one in based
michael@0:     // on the status code. The reason phrase is totally meaningless so its
michael@0:     // ok to have a default catch all here - but this makes debuggers and addons
michael@0:     // a little saner to use if we don't map things to "404 OK" or other nonsense.
michael@0:     // In particular, HTTP/2 does not use reason phrases at all so they need to
michael@0:     // always be injected.
michael@0: 
michael@0:     switch (mStatus) {
michael@0:         // start with the most common
michael@0:     case 200:
michael@0:         mStatusText.AssignLiteral("OK");
michael@0:         break;
michael@0:     case 404:
michael@0:         mStatusText.AssignLiteral("Not Found");
michael@0:         break;
michael@0:     case 301:
michael@0:         mStatusText.AssignLiteral("Moved Permanently");
michael@0:         break;
michael@0:     case 304:
michael@0:         mStatusText.AssignLiteral("Not Modified");
michael@0:         break;
michael@0:     case 307:
michael@0:         mStatusText.AssignLiteral("Temporary Redirect");
michael@0:         break;
michael@0:     case 500:
michael@0:         mStatusText.AssignLiteral("Internal Server Error");
michael@0:         break;
michael@0: 
michael@0:         // also well known
michael@0:     case 100:
michael@0:         mStatusText.AssignLiteral("Continue");
michael@0:         break;
michael@0:     case 101:
michael@0:         mStatusText.AssignLiteral("Switching Protocols");
michael@0:         break;
michael@0:     case 201:
michael@0:         mStatusText.AssignLiteral("Created");
michael@0:         break;
michael@0:     case 202:
michael@0:         mStatusText.AssignLiteral("Accepted");
michael@0:         break;
michael@0:     case 203:
michael@0:         mStatusText.AssignLiteral("Non Authoritative");
michael@0:         break;
michael@0:     case 204:
michael@0:         mStatusText.AssignLiteral("No Content");
michael@0:         break;
michael@0:     case 205:
michael@0:         mStatusText.AssignLiteral("Reset Content");
michael@0:         break;
michael@0:     case 206:
michael@0:         mStatusText.AssignLiteral("Partial Content");
michael@0:         break;
michael@0:     case 300:
michael@0:         mStatusText.AssignLiteral("Multiple Choices");
michael@0:         break;
michael@0:     case 302:
michael@0:         mStatusText.AssignLiteral("Found");
michael@0:         break;
michael@0:     case 303:
michael@0:         mStatusText.AssignLiteral("See Other");
michael@0:         break;
michael@0:     case 305:
michael@0:         mStatusText.AssignLiteral("Use Proxy");
michael@0:         break;
michael@0:     case 308:
michael@0:         mStatusText.AssignLiteral("Permanent Redirect");
michael@0:         break;
michael@0:     case 400:
michael@0:         mStatusText.AssignLiteral("Bad Request");
michael@0:         break;
michael@0:     case 401:
michael@0:         mStatusText.AssignLiteral("Unauthorized");
michael@0:         break;
michael@0:     case 402:
michael@0:         mStatusText.AssignLiteral("Payment Required");
michael@0:         break;
michael@0:     case 403:
michael@0:         mStatusText.AssignLiteral("Forbidden");
michael@0:         break;
michael@0:     case 405:
michael@0:         mStatusText.AssignLiteral("Method Not Allowed");
michael@0:         break;
michael@0:     case 406:
michael@0:         mStatusText.AssignLiteral("Not Acceptable");
michael@0:         break;
michael@0:     case 407:
michael@0:         mStatusText.AssignLiteral("Proxy Authentication Required");
michael@0:         break;
michael@0:     case 408:
michael@0:         mStatusText.AssignLiteral("Request Timeout");
michael@0:         break;
michael@0:     case 409:
michael@0:         mStatusText.AssignLiteral("Conflict");
michael@0:         break;
michael@0:     case 410:
michael@0:         mStatusText.AssignLiteral("Gone");
michael@0:         break;
michael@0:     case 411:
michael@0:         mStatusText.AssignLiteral("Length Required");
michael@0:         break;
michael@0:     case 412:
michael@0:         mStatusText.AssignLiteral("Precondition Failed");
michael@0:         break;
michael@0:     case 413:
michael@0:         mStatusText.AssignLiteral("Request Entity Too Large");
michael@0:         break;
michael@0:     case 414:
michael@0:         mStatusText.AssignLiteral("Request URI Too Long");
michael@0:         break;
michael@0:     case 415:
michael@0:         mStatusText.AssignLiteral("Unsupported Media Type");
michael@0:         break;
michael@0:     case 416:
michael@0:         mStatusText.AssignLiteral("Requested Range Not Satisfiable");
michael@0:         break;
michael@0:     case 417:
michael@0:         mStatusText.AssignLiteral("Expectation Failed");
michael@0:         break;
michael@0:     case 501:
michael@0:         mStatusText.AssignLiteral("Not Implemented");
michael@0:         break;
michael@0:     case 502:
michael@0:         mStatusText.AssignLiteral("Bad Gateway");
michael@0:         break;
michael@0:     case 503:
michael@0:         mStatusText.AssignLiteral("Service Unavailable");
michael@0:         break;
michael@0:     case 504:
michael@0:         mStatusText.AssignLiteral("Gateway Timeout");
michael@0:         break;
michael@0:     case 505:
michael@0:         mStatusText.AssignLiteral("HTTP Version Unsupported");
michael@0:         break;
michael@0:     default:
michael@0:         mStatusText.AssignLiteral("No Reason Phrase");
michael@0:         break;
michael@0:     }
michael@0: }
michael@0: 
michael@0: void
michael@0: nsHttpResponseHead::ParseStatusLine(const char *line)
michael@0: {
michael@0:     //
michael@0:     // Parse Status-Line:: HTTP-Version SP Status-Code SP Reason-Phrase CRLF
michael@0:     //
michael@0: 
michael@0:     // HTTP-Version
michael@0:     ParseVersion(line);
michael@0: 
michael@0:     if ((mVersion == NS_HTTP_VERSION_0_9) || !(line = PL_strchr(line, ' '))) {
michael@0:         mStatus = 200;
michael@0:         AssignDefaultStatusText();
michael@0:     }
michael@0:     else {
michael@0:         // Status-Code
michael@0:         mStatus = (uint16_t) atoi(++line);
michael@0:         if (mStatus == 0) {
michael@0:             LOG(("mal-formed response status; assuming status = 200\n"));
michael@0:             mStatus = 200;
michael@0:         }
michael@0: 
michael@0:         // Reason-Phrase is whatever is remaining of the line
michael@0:         if (!(line = PL_strchr(line, ' '))) {
michael@0:             AssignDefaultStatusText();
michael@0:         }
michael@0:         else
michael@0:             mStatusText = nsDependentCString(++line);
michael@0:     }
michael@0: 
michael@0:     LOG(("Have status line [version=%u status=%u statusText=%s]\n",
michael@0:         unsigned(mVersion), unsigned(mStatus), mStatusText.get()));
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsHttpResponseHead::ParseHeaderLine(const char *line)
michael@0: {
michael@0:     nsHttpAtom hdr = {0};
michael@0:     char *val;
michael@0:     nsresult rv;
michael@0: 
michael@0:     rv = mHeaders.ParseHeaderLine(line, &hdr, &val);
michael@0:     if (NS_FAILED(rv))
michael@0:         return rv;
michael@0: 
michael@0:     // leading and trailing LWS has been removed from |val|
michael@0: 
michael@0:     // handle some special case headers...
michael@0:     if (hdr == nsHttp::Content_Length) {
michael@0:         int64_t len;
michael@0:         const char *ignored;
michael@0:         // permit only a single value here.
michael@0:         if (nsHttp::ParseInt64(val, &ignored, &len)) {
michael@0:             mContentLength = len;
michael@0:         }
michael@0:         else {
michael@0:             // If this is a negative content length then just ignore it
michael@0:             LOG(("invalid content-length! %s\n", val));
michael@0:         }
michael@0:     }
michael@0:     else if (hdr == nsHttp::Content_Type) {
michael@0:         LOG(("ParseContentType [type=%s]\n", val));
michael@0:         bool dummy;
michael@0:         net_ParseContentType(nsDependentCString(val),
michael@0:                              mContentType, mContentCharset, &dummy);
michael@0:     }
michael@0:     else if (hdr == nsHttp::Cache_Control)
michael@0:         ParseCacheControl(val);
michael@0:     else if (hdr == nsHttp::Pragma)
michael@0:         ParsePragma(val);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: // From section 13.2.3 of RFC2616, we compute the current age of a cached
michael@0: // response as follows:
michael@0: //
michael@0: //    currentAge = max(max(0, responseTime - dateValue), ageValue)
michael@0: //               + now - requestTime
michael@0: //
michael@0: //    where responseTime == now
michael@0: //
michael@0: // This is typically a very small number.
michael@0: //
michael@0: nsresult
michael@0: nsHttpResponseHead::ComputeCurrentAge(uint32_t now,
michael@0:                                       uint32_t requestTime,
michael@0:                                       uint32_t *result) const
michael@0: {
michael@0:     uint32_t dateValue;
michael@0:     uint32_t ageValue;
michael@0: 
michael@0:     *result = 0;
michael@0: 
michael@0:     if (NS_FAILED(GetDateValue(&dateValue))) {
michael@0:         LOG(("nsHttpResponseHead::ComputeCurrentAge [this=%p] "
michael@0:              "Date response header not set!\n", this));
michael@0:         // Assume we have a fast connection and that our clock
michael@0:         // is in sync with the server.
michael@0:         dateValue = now;
michael@0:     }
michael@0: 
michael@0:     // Compute apparent age
michael@0:     if (now > dateValue)
michael@0:         *result = now - dateValue;
michael@0: 
michael@0:     // Compute corrected received age
michael@0:     if (NS_SUCCEEDED(GetAgeValue(&ageValue)))
michael@0:         *result = std::max(*result, ageValue);
michael@0: 
michael@0:     MOZ_ASSERT(now >= requestTime, "bogus request time");
michael@0: 
michael@0:     // Compute current age
michael@0:     *result += (now - requestTime);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: // From section 13.2.4 of RFC2616, we compute the freshness lifetime of a cached
michael@0: // response as follows:
michael@0: //
michael@0: //     freshnessLifetime = max_age_value
michael@0: // <or>
michael@0: //     freshnessLifetime = expires_value - date_value
michael@0: // <or>
michael@0: //     freshnessLifetime = (date_value - last_modified_value) * 0.10
michael@0: // <or>
michael@0: //     freshnessLifetime = 0
michael@0: //
michael@0: nsresult
michael@0: nsHttpResponseHead::ComputeFreshnessLifetime(uint32_t *result) const
michael@0: {
michael@0:     *result = 0;
michael@0: 
michael@0:     // Try HTTP/1.1 style max-age directive...
michael@0:     if (NS_SUCCEEDED(GetMaxAgeValue(result)))
michael@0:         return NS_OK;
michael@0: 
michael@0:     *result = 0;
michael@0: 
michael@0:     uint32_t date = 0, date2 = 0;
michael@0:     if (NS_FAILED(GetDateValue(&date)))
michael@0:         date = NowInSeconds(); // synthesize a date header if none exists
michael@0: 
michael@0:     // Try HTTP/1.0 style expires header...
michael@0:     if (NS_SUCCEEDED(GetExpiresValue(&date2))) {
michael@0:         if (date2 > date)
michael@0:             *result = date2 - date;
michael@0:         // the Expires header can specify a date in the past.
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     // Fallback on heuristic using last modified header...
michael@0:     if (NS_SUCCEEDED(GetLastModifiedValue(&date2))) {
michael@0:         LOG(("using last-modified to determine freshness-lifetime\n"));
michael@0:         LOG(("last-modified = %u, date = %u\n", date2, date));
michael@0:         if (date2 <= date) {
michael@0:             // this only makes sense if last-modified is actually in the past
michael@0:             *result = (date - date2) / 10;
michael@0:             return NS_OK;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // These responses can be cached indefinitely.
michael@0:     if ((mStatus == 300) || nsHttp::IsPermanentRedirect(mStatus)) {
michael@0:         *result = uint32_t(-1);
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     LOG(("nsHttpResponseHead::ComputeFreshnessLifetime [this = %x] "
michael@0:          "Insufficient information to compute a non-zero freshness "
michael@0:          "lifetime!\n", this));
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsHttpResponseHead::MustValidate() const
michael@0: {
michael@0:     LOG(("nsHttpResponseHead::MustValidate ??\n"));
michael@0: 
michael@0:     // Some response codes are cacheable, but the rest are not.  This switch
michael@0:     // should stay in sync with the list in nsHttpChannel::ProcessResponse
michael@0:     switch (mStatus) {
michael@0:         // Success codes
michael@0:     case 200:
michael@0:     case 203:
michael@0:     case 206:
michael@0:         // Cacheable redirects
michael@0:     case 300:
michael@0:     case 301:
michael@0:     case 302:
michael@0:     case 304:
michael@0:     case 307:
michael@0:     case 308:
michael@0:         break;
michael@0:         // Uncacheable redirects
michael@0:     case 303:
michael@0:     case 305:
michael@0:         // Other known errors
michael@0:     case 401:
michael@0:     case 407:
michael@0:     case 412:
michael@0:     case 416:
michael@0:     default:  // revalidate unknown error pages
michael@0:         LOG(("Must validate since response is an uncacheable error page\n"));
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     // The no-cache response header indicates that we must validate this
michael@0:     // cached response before reusing.
michael@0:     if (NoCache()) {
michael@0:         LOG(("Must validate since response contains 'no-cache' header\n"));
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     // Likewise, if the response is no-store, then we must validate this
michael@0:     // cached response before reusing.  NOTE: it may seem odd that a no-store
michael@0:     // response may be cached, but indeed all responses are cached in order
michael@0:     // to support File->SaveAs, View->PageSource, and other browser features.
michael@0:     if (NoStore()) {
michael@0:         LOG(("Must validate since response contains 'no-store' header\n"));
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     // Compare the Expires header to the Date header.  If the server sent an
michael@0:     // Expires header with a timestamp in the past, then we must validate this
michael@0:     // cached response before reusing.
michael@0:     if (ExpiresInPast()) {
michael@0:         LOG(("Must validate since Expires < Date\n"));
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     LOG(("no mandatory validation requirement\n"));
michael@0:     return false;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsHttpResponseHead::MustValidateIfExpired() const
michael@0: {
michael@0:     // according to RFC2616, section 14.9.4:
michael@0:     //
michael@0:     //  When the must-revalidate directive is present in a response received by a
michael@0:     //  cache, that cache MUST NOT use the entry after it becomes stale to respond to
michael@0:     //  a subsequent request without first revalidating it with the origin server.
michael@0:     //
michael@0:     return HasHeaderValue(nsHttp::Cache_Control, "must-revalidate");
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsHttpResponseHead::IsResumable() const
michael@0: {
michael@0:     // even though some HTTP/1.0 servers may support byte range requests, we're not
michael@0:     // going to bother with them, since those servers wouldn't understand If-Range.
michael@0:     // Also, while in theory it may be possible to resume when the status code
michael@0:     // is not 200, it is unlikely to be worth the trouble, especially for
michael@0:     // non-2xx responses.
michael@0:     return mStatus == 200 &&
michael@0:            mVersion >= NS_HTTP_VERSION_1_1 &&
michael@0:            PeekHeader(nsHttp::Content_Length) &&
michael@0:           (PeekHeader(nsHttp::ETag) || PeekHeader(nsHttp::Last_Modified)) &&
michael@0:            HasHeaderValue(nsHttp::Accept_Ranges, "bytes");
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsHttpResponseHead::ExpiresInPast() const
michael@0: {
michael@0:     uint32_t maxAgeVal, expiresVal, dateVal;
michael@0: 
michael@0:     // Bug #203271. Ensure max-age directive takes precedence over Expires
michael@0:     if (NS_SUCCEEDED(GetMaxAgeValue(&maxAgeVal))) {
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     return NS_SUCCEEDED(GetExpiresValue(&expiresVal)) &&
michael@0:            NS_SUCCEEDED(GetDateValue(&dateVal)) &&
michael@0:            expiresVal < dateVal;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsHttpResponseHead::UpdateHeaders(const nsHttpHeaderArray &headers)
michael@0: {
michael@0:     LOG(("nsHttpResponseHead::UpdateHeaders [this=%p]\n", this));
michael@0: 
michael@0:     uint32_t i, count = headers.Count();
michael@0:     for (i=0; i<count; ++i) {
michael@0:         nsHttpAtom header;
michael@0:         const char *val = headers.PeekHeaderAt(i, header);
michael@0: 
michael@0:         if (!val) {
michael@0:             continue;
michael@0:         }
michael@0: 
michael@0:         // Ignore any hop-by-hop headers...
michael@0:         if (header == nsHttp::Connection          ||
michael@0:             header == nsHttp::Proxy_Connection    ||
michael@0:             header == nsHttp::Keep_Alive          ||
michael@0:             header == nsHttp::Proxy_Authenticate  ||
michael@0:             header == nsHttp::Proxy_Authorization || // not a response header!
michael@0:             header == nsHttp::TE                  ||
michael@0:             header == nsHttp::Trailer             ||
michael@0:             header == nsHttp::Transfer_Encoding   ||
michael@0:             header == nsHttp::Upgrade             ||
michael@0:         // Ignore any non-modifiable headers...
michael@0:             header == nsHttp::Content_Location    ||
michael@0:             header == nsHttp::Content_MD5         ||
michael@0:             header == nsHttp::ETag                ||
michael@0:         // Assume Cache-Control: "no-transform"
michael@0:             header == nsHttp::Content_Encoding    ||
michael@0:             header == nsHttp::Content_Range       ||
michael@0:             header == nsHttp::Content_Type        ||
michael@0:         // Ignore wacky headers too...
michael@0:             // this one is for MS servers that send "Content-Length: 0"
michael@0:             // on 304 responses
michael@0:             header == nsHttp::Content_Length) {
michael@0:             LOG(("ignoring response header [%s: %s]\n", header.get(), val));
michael@0:         }
michael@0:         else {
michael@0:             LOG(("new response header [%s: %s]\n", header.get(), val));
michael@0: 
michael@0:             // overwrite the current header value with the new value...
michael@0:             SetHeader(header, nsDependentCString(val));
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsHttpResponseHead::Reset()
michael@0: {
michael@0:     LOG(("nsHttpResponseHead::Reset\n"));
michael@0: 
michael@0:     ClearHeaders();
michael@0: 
michael@0:     mVersion = NS_HTTP_VERSION_1_1;
michael@0:     mStatus = 200;
michael@0:     mContentLength = UINT64_MAX;
michael@0:     mCacheControlNoStore = false;
michael@0:     mCacheControlNoCache = false;
michael@0:     mPragmaNoCache = false;
michael@0:     mStatusText.Truncate();
michael@0:     mContentType.Truncate();
michael@0:     mContentCharset.Truncate();
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsHttpResponseHead::ParseDateHeader(nsHttpAtom header, uint32_t *result) const
michael@0: {
michael@0:     const char *val = PeekHeader(header);
michael@0:     if (!val)
michael@0:         return NS_ERROR_NOT_AVAILABLE;
michael@0: 
michael@0:     PRTime time;
michael@0:     PRStatus st = PR_ParseTimeString(val, true, &time);
michael@0:     if (st != PR_SUCCESS)
michael@0:         return NS_ERROR_NOT_AVAILABLE;
michael@0: 
michael@0:     *result = PRTimeToSeconds(time);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsHttpResponseHead::GetAgeValue(uint32_t *result) const
michael@0: {
michael@0:     const char *val = PeekHeader(nsHttp::Age);
michael@0:     if (!val)
michael@0:         return NS_ERROR_NOT_AVAILABLE;
michael@0: 
michael@0:     *result = (uint32_t) atoi(val);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: // Return the value of the (HTTP 1.1) max-age directive, which itself is a
michael@0: // component of the Cache-Control response header
michael@0: nsresult
michael@0: nsHttpResponseHead::GetMaxAgeValue(uint32_t *result) const
michael@0: {
michael@0:     const char *val = PeekHeader(nsHttp::Cache_Control);
michael@0:     if (!val)
michael@0:         return NS_ERROR_NOT_AVAILABLE;
michael@0: 
michael@0:     const char *p = nsHttp::FindToken(val, "max-age", HTTP_HEADER_VALUE_SEPS "=");
michael@0:     if (!p)
michael@0:         return NS_ERROR_NOT_AVAILABLE;
michael@0:     p += 7;
michael@0:     while (*p == ' ' || *p == '\t')
michael@0:         ++p;
michael@0:     if (*p != '=')
michael@0:         return NS_ERROR_NOT_AVAILABLE;
michael@0:     ++p;
michael@0:     while (*p == ' ' || *p == '\t')
michael@0:         ++p;
michael@0: 
michael@0:     int maxAgeValue = atoi(p);
michael@0:     if (maxAgeValue < 0)
michael@0:         maxAgeValue = 0;
michael@0:     *result = static_cast<uint32_t>(maxAgeValue);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsHttpResponseHead::GetExpiresValue(uint32_t *result) const
michael@0: {
michael@0:     const char *val = PeekHeader(nsHttp::Expires);
michael@0:     if (!val)
michael@0:         return NS_ERROR_NOT_AVAILABLE;
michael@0: 
michael@0:     PRTime time;
michael@0:     PRStatus st = PR_ParseTimeString(val, true, &time);
michael@0:     if (st != PR_SUCCESS) {
michael@0:         // parsing failed... RFC 2616 section 14.21 says we should treat this
michael@0:         // as an expiration time in the past.
michael@0:         *result = 0;
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     if (time < 0)
michael@0:         *result = 0;
michael@0:     else
michael@0:         *result = PRTimeToSeconds(time);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: int64_t
michael@0: nsHttpResponseHead::TotalEntitySize() const
michael@0: {
michael@0:     const char* contentRange = PeekHeader(nsHttp::Content_Range);
michael@0:     if (!contentRange)
michael@0:         return ContentLength();
michael@0: 
michael@0:     // Total length is after a slash
michael@0:     const char* slash = strrchr(contentRange, '/');
michael@0:     if (!slash)
michael@0:         return -1; // No idea what the length is
michael@0: 
michael@0:     slash++;
michael@0:     if (*slash == '*') // Server doesn't know the length
michael@0:         return -1;
michael@0: 
michael@0:     int64_t size;
michael@0:     if (!nsHttp::ParseInt64(slash, &size))
michael@0:         size = UINT64_MAX;
michael@0:     return size;
michael@0: }
michael@0: 
michael@0: //-----------------------------------------------------------------------------
michael@0: // nsHttpResponseHead <private>
michael@0: //-----------------------------------------------------------------------------
michael@0: 
michael@0: void
michael@0: nsHttpResponseHead::ParseVersion(const char *str)
michael@0: {
michael@0:     // Parse HTTP-Version:: "HTTP" "/" 1*DIGIT "." 1*DIGIT
michael@0: 
michael@0:     LOG(("nsHttpResponseHead::ParseVersion [version=%s]\n", str));
michael@0: 
michael@0:     // make sure we have HTTP at the beginning
michael@0:     if (PL_strncasecmp(str, "HTTP", 4) != 0) {
michael@0:         if (PL_strncasecmp(str, "ICY ", 4) == 0) {
michael@0:             // ShoutCast ICY is HTTP/1.0-like. Assume it is HTTP/1.0.
michael@0:             LOG(("Treating ICY as HTTP 1.0\n"));
michael@0:             mVersion = NS_HTTP_VERSION_1_0;
michael@0:             return;
michael@0:         }
michael@0:         LOG(("looks like a HTTP/0.9 response\n"));
michael@0:         mVersion = NS_HTTP_VERSION_0_9;
michael@0:         return;
michael@0:     }
michael@0:     str += 4;
michael@0: 
michael@0:     if (*str != '/') {
michael@0:         LOG(("server did not send a version number; assuming HTTP/1.0\n"));
michael@0:         // NCSA/1.5.2 has a bug in which it fails to send a version number
michael@0:         // if the request version is HTTP/1.1, so we fall back on HTTP/1.0
michael@0:         mVersion = NS_HTTP_VERSION_1_0;
michael@0:         return;
michael@0:     }
michael@0: 
michael@0:     char *p = PL_strchr(str, '.');
michael@0:     if (p == nullptr) {
michael@0:         LOG(("mal-formed server version; assuming HTTP/1.0\n"));
michael@0:         mVersion = NS_HTTP_VERSION_1_0;
michael@0:         return;
michael@0:     }
michael@0: 
michael@0:     ++p; // let b point to the minor version
michael@0: 
michael@0:     int major = atoi(str + 1);
michael@0:     int minor = atoi(p);
michael@0: 
michael@0:     if ((major > 2) || ((major == 2) && (minor >= 0)))
michael@0:         mVersion = NS_HTTP_VERSION_2_0;
michael@0:     else if ((major == 1) && (minor >= 1))
michael@0:         // at least HTTP/1.1
michael@0:         mVersion = NS_HTTP_VERSION_1_1;
michael@0:     else
michael@0:         // treat anything else as version 1.0
michael@0:         mVersion = NS_HTTP_VERSION_1_0;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsHttpResponseHead::ParseCacheControl(const char *val)
michael@0: {
michael@0:     if (!(val && *val)) {
michael@0:         // clear flags
michael@0:         mCacheControlNoCache = false;
michael@0:         mCacheControlNoStore = false;
michael@0:         return;
michael@0:     }
michael@0: 
michael@0:     // search header value for occurrence(s) of "no-cache" but ignore
michael@0:     // occurrence(s) of "no-cache=blah"
michael@0:     if (nsHttp::FindToken(val, "no-cache", HTTP_HEADER_VALUE_SEPS))
michael@0:         mCacheControlNoCache = true;
michael@0: 
michael@0:     // search header value for occurrence of "no-store"
michael@0:     if (nsHttp::FindToken(val, "no-store", HTTP_HEADER_VALUE_SEPS))
michael@0:         mCacheControlNoStore = true;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsHttpResponseHead::ParsePragma(const char *val)
michael@0: {
michael@0:     LOG(("nsHttpResponseHead::ParsePragma [val=%s]\n", val));
michael@0: 
michael@0:     if (!(val && *val)) {
michael@0:         // clear no-cache flag
michael@0:         mPragmaNoCache = false;
michael@0:         return;
michael@0:     }
michael@0: 
michael@0:     // Although 'Pragma: no-cache' is not a standard HTTP response header (it's
michael@0:     // a request header), caching is inhibited when this header is present so
michael@0:     // as to match existing Navigator behavior.
michael@0:     if (nsHttp::FindToken(val, "no-cache", HTTP_HEADER_VALUE_SEPS))
michael@0:         mPragmaNoCache = true;
michael@0: }
michael@0: 
michael@0: } // namespace mozilla::net
michael@0: } // namespace mozilla