| // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #include "net/http/partial_data.h" | |
| #include "base/bind.h" | |
| #include "base/bind_helpers.h" | |
| #include "base/format_macros.h" | |
| #include "base/logging.h" | |
| #include "base/string_number_conversions.h" | |
| #include "base/string_util.h" | |
| #include "base/stringprintf.h" | |
| #include "net/base/net_errors.h" | |
| #include "net/disk_cache/disk_cache.h" | |
| #include "net/http/http_response_headers.h" | |
| #include "net/http/http_util.h" | |
| namespace net { | |
| namespace { | |
| // The headers that we have to process. | |
| const char kLengthHeader[] = "Content-Length"; | |
| const char kRangeHeader[] = "Content-Range"; | |
| const int kDataStream = 1; | |
| void AddRangeHeader(int64 start, int64 end, HttpRequestHeaders* headers) { | |
| DCHECK(start >= 0 || end >= 0); | |
| std::string my_start, my_end; | |
| if (start >= 0) | |
| my_start = base::Int64ToString(start); | |
| if (end >= 0) | |
| my_end = base::Int64ToString(end); | |
| headers->SetHeader( | |
| HttpRequestHeaders::kRange, | |
| base::StringPrintf("bytes=%s-%s", my_start.c_str(), my_end.c_str())); | |
| } | |
| } // namespace | |
| // A core object that can be detached from the Partialdata object at destruction | |
| // so that asynchronous operations cleanup can be performed. | |
| class PartialData::Core { | |
| public: | |
| // Build a new core object. Lifetime management is automatic. | |
| static Core* CreateCore(PartialData* owner) { | |
| return new Core(owner); | |
| } | |
| // Wrapper for Entry::GetAvailableRange. If this method returns ERR_IO_PENDING | |
| // PartialData::GetAvailableRangeCompleted() will be invoked on the owner | |
| // object when finished (unless Cancel() is called first). | |
| int GetAvailableRange(disk_cache::Entry* entry, int64 offset, int len, | |
| int64* start); | |
| // Cancels a pending operation. It is a mistake to call this method if there | |
| // is no operation in progress; in fact, there will be no object to do so. | |
| void Cancel(); | |
| private: | |
| explicit Core(PartialData* owner); | |
| ~Core(); | |
| // Pending io completion routine. | |
| void OnIOComplete(int result); | |
| PartialData* owner_; | |
| int64 start_; | |
| DISALLOW_COPY_AND_ASSIGN(Core); | |
| }; | |
| PartialData::Core::Core(PartialData* owner) | |
| : owner_(owner), start_(0) { | |
| DCHECK(!owner_->core_); | |
| owner_->core_ = this; | |
| } | |
| PartialData::Core::~Core() { | |
| if (owner_) | |
| owner_->core_ = NULL; | |
| } | |
| void PartialData::Core::Cancel() { | |
| DCHECK(owner_); | |
| owner_ = NULL; | |
| } | |
| int PartialData::Core::GetAvailableRange(disk_cache::Entry* entry, int64 offset, | |
| int len, int64* start) { | |
| int rv = entry->GetAvailableRange( | |
| offset, len, &start_, base::Bind(&PartialData::Core::OnIOComplete, | |
| base::Unretained(this))); | |
| if (rv != net::ERR_IO_PENDING) { | |
| // The callback will not be invoked. Lets cleanup. | |
| *start = start_; | |
| delete this; | |
| } | |
| return rv; | |
| } | |
| void PartialData::Core::OnIOComplete(int result) { | |
| if (owner_) | |
| owner_->GetAvailableRangeCompleted(result, start_); | |
| delete this; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| PartialData::PartialData() | |
| : range_present_(false), | |
| final_range_(false), | |
| sparse_entry_(true), | |
| truncated_(false), | |
| initial_validation_(false), | |
| core_(NULL) { | |
| } | |
| PartialData::~PartialData() { | |
| if (core_) | |
| core_->Cancel(); | |
| } | |
| bool PartialData::Init(const HttpRequestHeaders& headers) { | |
| std::string range_header; | |
| if (!headers.GetHeader(HttpRequestHeaders::kRange, &range_header)) | |
| return false; | |
| std::vector<HttpByteRange> ranges; | |
| if (!HttpUtil::ParseRangeHeader(range_header, &ranges) || ranges.size() != 1) | |
| return false; | |
| // We can handle this range request. | |
| byte_range_ = ranges[0]; | |
| if (!byte_range_.IsValid()) | |
| return false; | |
| resource_size_ = 0; | |
| current_range_start_ = byte_range_.first_byte_position(); | |
| DVLOG(1) << "Range start: " << current_range_start_ << " end: " << | |
| byte_range_.last_byte_position(); | |
| return true; | |
| } | |
| void PartialData::SetHeaders(const HttpRequestHeaders& headers) { | |
| DCHECK(extra_headers_.IsEmpty()); | |
| extra_headers_.CopyFrom(headers); | |
| } | |
| void PartialData::RestoreHeaders(HttpRequestHeaders* headers) const { | |
| DCHECK(current_range_start_ >= 0 || byte_range_.IsSuffixByteRange()); | |
| int64 end = byte_range_.IsSuffixByteRange() ? | |
| byte_range_.suffix_length() : byte_range_.last_byte_position(); | |
| headers->CopyFrom(extra_headers_); | |
| if (!truncated_ && byte_range_.IsValid()) | |
| AddRangeHeader(current_range_start_, end, headers); | |
| } | |
| int PartialData::ShouldValidateCache(disk_cache::Entry* entry, | |
| const CompletionCallback& callback) { | |
| DCHECK_GE(current_range_start_, 0); | |
| // Scan the disk cache for the first cached portion within this range. | |
| int len = GetNextRangeLen(); | |
| if (!len) | |
| return 0; | |
| DVLOG(3) << "ShouldValidateCache len: " << len; | |
| if (sparse_entry_) { | |
| DCHECK(callback_.is_null()); | |
| Core* core = Core::CreateCore(this); | |
| cached_min_len_ = core->GetAvailableRange(entry, current_range_start_, len, | |
| &cached_start_); | |
| if (cached_min_len_ == ERR_IO_PENDING) { | |
| callback_ = callback; | |
| return ERR_IO_PENDING; | |
| } | |
| } else if (!truncated_) { | |
| if (byte_range_.HasFirstBytePosition() && | |
| byte_range_.first_byte_position() >= resource_size_) { | |
| // The caller should take care of this condition because we should have | |
| // failed IsRequestedRangeOK(), but it's better to be consistent here. | |
| len = 0; | |
| } | |
| cached_min_len_ = len; | |
| cached_start_ = current_range_start_; | |
| } | |
| if (cached_min_len_ < 0) | |
| return cached_min_len_; | |
| // Return a positive number to indicate success (versus error or finished). | |
| return 1; | |
| } | |
| void PartialData::PrepareCacheValidation(disk_cache::Entry* entry, | |
| HttpRequestHeaders* headers) { | |
| DCHECK_GE(current_range_start_, 0); | |
| DCHECK_GE(cached_min_len_, 0); | |
| int len = GetNextRangeLen(); | |
| DCHECK_NE(0, len); | |
| range_present_ = false; | |
| headers->CopyFrom(extra_headers_); | |
| if (!cached_min_len_) { | |
| // We don't have anything else stored. | |
| final_range_ = true; | |
| cached_start_ = | |
| byte_range_.HasLastBytePosition() ? current_range_start_ + len : 0; | |
| } | |
| if (current_range_start_ == cached_start_) { | |
| // The data lives in the cache. | |
| range_present_ = true; | |
| if (len == cached_min_len_) | |
| final_range_ = true; | |
| AddRangeHeader(current_range_start_, cached_start_ + cached_min_len_ - 1, | |
| headers); | |
| } else { | |
| // This range is not in the cache. | |
| AddRangeHeader(current_range_start_, cached_start_ - 1, headers); | |
| } | |
| } | |
| bool PartialData::IsCurrentRangeCached() const { | |
| return range_present_; | |
| } | |
| bool PartialData::IsLastRange() const { | |
| return final_range_; | |
| } | |
| bool PartialData::UpdateFromStoredHeaders(const HttpResponseHeaders* headers, | |
| disk_cache::Entry* entry, | |
| bool truncated) { | |
| resource_size_ = 0; | |
| if (truncated) { | |
| DCHECK_EQ(headers->response_code(), 200); | |
| // We don't have the real length and the user may be trying to create a | |
| // sparse entry so let's not write to this entry. | |
| if (byte_range_.IsValid()) | |
| return false; | |
| if (!headers->HasStrongValidators()) | |
| return false; | |
| // Now we avoid resume if there is no content length, but that was not | |
| // always the case so double check here. | |
| int64 total_length = headers->GetContentLength(); | |
| if (total_length <= 0) | |
| return false; | |
| truncated_ = true; | |
| initial_validation_ = true; | |
| sparse_entry_ = false; | |
| int current_len = entry->GetDataSize(kDataStream); | |
| byte_range_.set_first_byte_position(current_len); | |
| resource_size_ = total_length; | |
| current_range_start_ = current_len; | |
| cached_min_len_ = current_len; | |
| cached_start_ = current_len + 1; | |
| return true; | |
| } | |
| if (headers->response_code() != 206) { | |
| DCHECK(byte_range_.IsValid()); | |
| sparse_entry_ = false; | |
| resource_size_ = entry->GetDataSize(kDataStream); | |
| DVLOG(2) << "UpdateFromStoredHeaders size: " << resource_size_; | |
| return true; | |
| } | |
| if (!headers->HasStrongValidators()) | |
| return false; | |
| int64 length_value = headers->GetContentLength(); | |
| if (length_value <= 0) | |
| return false; // We must have stored the resource length. | |
| resource_size_ = length_value; | |
| // Make sure that this is really a sparse entry. | |
| return entry->CouldBeSparse(); | |
| } | |
| void PartialData::SetRangeToStartDownload() { | |
| DCHECK(truncated_); | |
| DCHECK(!sparse_entry_); | |
| current_range_start_ = 0; | |
| cached_start_ = 0; | |
| initial_validation_ = false; | |
| } | |
| bool PartialData::IsRequestedRangeOK() { | |
| if (byte_range_.IsValid()) { | |
| if (!byte_range_.ComputeBounds(resource_size_)) | |
| return false; | |
| if (truncated_) | |
| return true; | |
| if (current_range_start_ < 0) | |
| current_range_start_ = byte_range_.first_byte_position(); | |
| } else { | |
| // This is not a range request but we have partial data stored. | |
| current_range_start_ = 0; | |
| byte_range_.set_last_byte_position(resource_size_ - 1); | |
| } | |
| bool rv = current_range_start_ >= 0; | |
| if (!rv) | |
| current_range_start_ = 0; | |
| return rv; | |
| } | |
| bool PartialData::ResponseHeadersOK(const HttpResponseHeaders* headers) { | |
| if (headers->response_code() == 304) { | |
| if (!byte_range_.IsValid() || truncated_) | |
| return true; | |
| // We must have a complete range here. | |
| return byte_range_.HasFirstBytePosition() && | |
| byte_range_.HasLastBytePosition(); | |
| } | |
| int64 start, end, total_length; | |
| if (!headers->GetContentRange(&start, &end, &total_length)) | |
| return false; | |
| if (total_length <= 0) | |
| return false; | |
| int64 content_length = headers->GetContentLength(); | |
| if (content_length < 0 || content_length != end - start + 1) | |
| return false; | |
| if (!resource_size_) { | |
| // First response. Update our values with the ones provided by the server. | |
| resource_size_ = total_length; | |
| if (!byte_range_.HasFirstBytePosition()) { | |
| byte_range_.set_first_byte_position(start); | |
| current_range_start_ = start; | |
| } | |
| if (!byte_range_.HasLastBytePosition()) | |
| byte_range_.set_last_byte_position(end); | |
| } else if (resource_size_ != total_length) { | |
| return false; | |
| } | |
| if (truncated_) { | |
| if (!byte_range_.HasLastBytePosition()) | |
| byte_range_.set_last_byte_position(end); | |
| } | |
| if (start != current_range_start_) | |
| return false; | |
| if (byte_range_.IsValid() && end > byte_range_.last_byte_position()) | |
| return false; | |
| return true; | |
| } | |
| // We are making multiple requests to complete the range requested by the user. | |
| // Just assume that everything is fine and say that we are returning what was | |
| // requested. | |
| void PartialData::FixResponseHeaders(HttpResponseHeaders* headers, | |
| bool success) { | |
| if (truncated_) | |
| return; | |
| headers->RemoveHeader(kLengthHeader); | |
| headers->RemoveHeader(kRangeHeader); | |
| int64 range_len, start, end; | |
| if (byte_range_.IsValid()) { | |
| if (success) { | |
| if (!sparse_entry_) | |
| headers->ReplaceStatusLine("HTTP/1.1 206 Partial Content"); | |
| DCHECK(byte_range_.HasFirstBytePosition()); | |
| DCHECK(byte_range_.HasLastBytePosition()); | |
| start = byte_range_.first_byte_position(); | |
| end = byte_range_.last_byte_position(); | |
| range_len = end - start + 1; | |
| } else { | |
| headers->ReplaceStatusLine( | |
| "HTTP/1.1 416 Requested Range Not Satisfiable"); | |
| start = 0; | |
| end = 0; | |
| range_len = 0; | |
| } | |
| headers->AddHeader( | |
| base::StringPrintf("%s: bytes %" PRId64 "-%" PRId64 "/%" PRId64, | |
| kRangeHeader, start, end, resource_size_)); | |
| } else { | |
| // TODO(rvargas): Is it safe to change the protocol version? | |
| headers->ReplaceStatusLine("HTTP/1.1 200 OK"); | |
| DCHECK_NE(resource_size_, 0); | |
| range_len = resource_size_; | |
| } | |
| headers->AddHeader(base::StringPrintf("%s: %" PRId64, kLengthHeader, | |
| range_len)); | |
| } | |
| void PartialData::FixContentLength(HttpResponseHeaders* headers) { | |
| headers->RemoveHeader(kLengthHeader); | |
| headers->AddHeader(base::StringPrintf("%s: %" PRId64, kLengthHeader, | |
| resource_size_)); | |
| } | |
| int PartialData::CacheRead( | |
| disk_cache::Entry* entry, IOBuffer* data, int data_len, | |
| const net::CompletionCallback& callback) { | |
| int read_len = std::min(data_len, cached_min_len_); | |
| if (!read_len) | |
| return 0; | |
| int rv = 0; | |
| if (sparse_entry_) { | |
| rv = entry->ReadSparseData(current_range_start_, data, read_len, | |
| callback); | |
| } else { | |
| if (current_range_start_ > kint32max) | |
| return ERR_INVALID_ARGUMENT; | |
| rv = entry->ReadData(kDataStream, static_cast<int>(current_range_start_), | |
| data, read_len, callback); | |
| } | |
| return rv; | |
| } | |
| int PartialData::CacheWrite( | |
| disk_cache::Entry* entry, IOBuffer* data, int data_len, | |
| const net::CompletionCallback& callback) { | |
| DVLOG(3) << "To write: " << data_len; | |
| if (sparse_entry_) { | |
| return entry->WriteSparseData( | |
| current_range_start_, data, data_len, callback); | |
| } else { | |
| if (current_range_start_ > kint32max) | |
| return ERR_INVALID_ARGUMENT; | |
| return entry->WriteData(kDataStream, static_cast<int>(current_range_start_), | |
| data, data_len, callback, true); | |
| } | |
| } | |
| void PartialData::OnCacheReadCompleted(int result) { | |
| DVLOG(3) << "Read: " << result; | |
| if (result > 0) { | |
| current_range_start_ += result; | |
| cached_min_len_ -= result; | |
| DCHECK_GE(cached_min_len_, 0); | |
| } | |
| } | |
| void PartialData::OnNetworkReadCompleted(int result) { | |
| if (result > 0) | |
| current_range_start_ += result; | |
| } | |
| int PartialData::GetNextRangeLen() { | |
| int64 range_len = | |
| byte_range_.HasLastBytePosition() ? | |
| byte_range_.last_byte_position() - current_range_start_ + 1 : | |
| kint32max; | |
| if (range_len > kint32max) | |
| range_len = kint32max; | |
| return static_cast<int32>(range_len); | |
| } | |
| void PartialData::GetAvailableRangeCompleted(int result, int64 start) { | |
| DCHECK(!callback_.is_null()); | |
| DCHECK_NE(ERR_IO_PENDING, result); | |
| cached_start_ = start; | |
| cached_min_len_ = result; | |
| if (result >= 0) | |
| result = 1; // Return success, go ahead and validate the entry. | |
| CompletionCallback cb = callback_; | |
| callback_.Reset(); | |
| cb.Run(result); | |
| } | |
| } // namespace net |