PRBool
nsHttpResponseHead::IsResumable()
{
// even though some HTTP/1.0 servers may support byte range requests, we're not
// going to bother with them, since those servers wouldn't understand If-Range.
return mVersion >= NS_HTTP_VERSION_1_1 &&
PeekHeader(nsHttp::Content_Length) &&
(PeekHeader(nsHttp::ETag) || PeekHeader(nsHttp::Last_Modified)) &&
HasHeaderValue(nsHttp::Accept_Ranges, "bytes");
}
bool
nsHttpResponseHead::IsResumable() const
{
// even though some HTTP/1.0 servers may support byte range requests, we're not
// going to bother with them, since those servers wouldn't understand If-Range.
// Also, while in theory it may be possible to resume when the status code
// is not 200, it is unlikely to be worth the trouble, especially for
// non-2xx responses.
return mStatus == 200 &&
mVersion >= NS_HTTP_VERSION_1_1 &&
PeekHeader(nsHttp::Content_Length) &&
(PeekHeader(nsHttp::ETag) || PeekHeader(nsHttp::Last_Modified)) &&
HasHeaderValue(nsHttp::Accept_Ranges, "bytes");
}
// Return the value of the (HTTP 1.1) max-age directive, which itself is a
// component of the Cache-Control response header
nsresult
nsHttpResponseHead::GetMaxAgeValue(uint32_t *result) const
{
const char *val = PeekHeader(nsHttp::Cache_Control);
if (!val)
return NS_ERROR_NOT_AVAILABLE;
const char *p = nsHttp::FindToken(val, "max-age", HTTP_HEADER_VALUE_SEPS "=");
if (!p)
return NS_ERROR_NOT_AVAILABLE;
p += 7;
while (*p == ' ' || *p == '\t')
++p;
if (*p != '=')
return NS_ERROR_NOT_AVAILABLE;
++p;
while (*p == ' ' || *p == '\t')
++p;
int maxAgeValue = atoi(p);
if (maxAgeValue < 0)
maxAgeValue = 0;
*result = static_cast<uint32_t>(maxAgeValue);
return NS_OK;
}
nsresult
nsHttpResponseHead::GetAgeValue(uint32_t *result) const
{
const char *val = PeekHeader(nsHttp::Age);
if (!val)
return NS_ERROR_NOT_AVAILABLE;
*result = (uint32_t) atoi(val);
return NS_OK;
}
PRBool
nsHttpResponseHead::MustValidateIfExpired()
{
// according to RFC2616, section 14.9.4:
//
// When the must-revalidate directive is present in a response received by a
// cache, that cache MUST NOT use the entry after it becomes stale to respond to
// a subsequent request without first revalidating it with the origin server.
//
const char *val = PeekHeader(nsHttp::Cache_Control);
return val && PL_strcasestr(val, "must-revalidate");
}
// Return the value of the (HTTP 1.1) max-age directive, which itself is a
// component of the Cache-Control response header
nsresult
nsHttpResponseHead::GetMaxAgeValue(PRUint32 *result)
{
const char *val = PeekHeader(nsHttp::Cache_Control);
if (!val)
return NS_ERROR_NOT_AVAILABLE;
const char *p = PL_strcasestr(val, "max-age=");
if (!p)
return NS_ERROR_NOT_AVAILABLE;
*result = (PRUint32) atoi(p + 8);
return NS_OK;
}
nsresult
nsHttpResponseHead::ParseDateHeader(nsHttpAtom header, uint32_t *result) const
{
const char *val = PeekHeader(header);
if (!val)
return NS_ERROR_NOT_AVAILABLE;
PRTime time;
PRStatus st = PR_ParseTimeString(val, true, &time);
if (st != PR_SUCCESS)
return NS_ERROR_NOT_AVAILABLE;
*result = PRTimeToSeconds(time);
return NS_OK;
}
// Return the value of the (HTTP 1.1) max-age directive, which itself is a
// component of the Cache-Control response header
nsresult
nsHttpResponseHead::GetMaxAgeValue(uint32_t *result) const
{
const char *val = PeekHeader(nsHttp::Cache_Control);
if (!val)
return NS_ERROR_NOT_AVAILABLE;
const char *p = PL_strcasestr(val, "max-age=");
if (!p)
return NS_ERROR_NOT_AVAILABLE;
int maxAgeValue = atoi(p + 8);
if (maxAgeValue < 0)
maxAgeValue = 0;
*result = uint32_t(maxAgeValue);
return NS_OK;
}
nsresult
nsHttpResponseHead::GetExpiresValue(PRUint32 *result)
{
const char *val = PeekHeader(nsHttp::Expires);
if (!val)
return NS_ERROR_NOT_AVAILABLE;
PRTime time;
PRStatus st = PR_ParseTimeString(val, PR_TRUE, &time);
if (st != PR_SUCCESS) {
// parsing failed... RFC 2616 section 14.21 says we should treat this
// as an expiration time in the past.
*result = 0;
return NS_OK;
}
if (LL_CMP(time, <, LL_Zero()))
*result = 0;
else
int64_t
nsHttpResponseHead::TotalEntitySize() const
{
const char* contentRange = PeekHeader(nsHttp::Content_Range);
if (!contentRange)
return ContentLength();
// Total length is after a slash
const char* slash = strrchr(contentRange, '/');
if (!slash)
return -1; // No idea what the length is
slash++;
if (*slash == '*') // Server doesn't know the length
return -1;
int64_t size;
if (!nsHttp::ParseInt64(slash, &size))
size = UINT64_MAX;
return size;
}
nsresult
nsHttpResponseHead::GetExpiresValue(uint32_t *result) const
{
const char *val = PeekHeader(nsHttp::Expires);
if (!val)
return NS_ERROR_NOT_AVAILABLE;
PRTime time;
PRStatus st = PR_ParseTimeString(val, true, &time);
if (st != PR_SUCCESS) {
// parsing failed... RFC 2616 section 14.21 says we should treat this
// as an expiration time in the past.
*result = 0;
return NS_OK;
}
if (time < 0)
*result = 0;
else
*result = PRTimeToSeconds(time);
return NS_OK;
}