Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(254)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: webrtc/base/httpbase.cc

Issue 2877023002: Move webrtc/{base => rtc_base} (Closed)
Patch Set: update presubmit.py and DEPS include rules Created 3 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « webrtc/base/httpbase.h ('k') | webrtc/base/httpbase_unittest.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: webrtc/base/httpbase.cc
diff --git a/webrtc/base/httpbase.cc b/webrtc/base/httpbase.cc
deleted file mode 100644
index bc8ac64c711c1abb33201c0c281ca38ed4c60aa8..0000000000000000000000000000000000000000
--- a/webrtc/base/httpbase.cc
+++ /dev/null
@@ -1,886 +0,0 @@
-/*
- * Copyright 2004 The WebRTC Project Authors. All rights reserved.
- *
- * Use of this source code is governed by a BSD-style license
- * that can be found in the LICENSE file in the root of the source
- * tree. An additional intellectual property rights grant can be found
- * in the file PATENTS. All contributing project authors may
- * be found in the AUTHORS file in the root of the source tree.
- */
-
-#include <memory>
-
-#if defined(WEBRTC_WIN)
-#include "webrtc/base/win32.h"
-#else // !WEBRTC_WIN
-#define SEC_E_CERT_EXPIRED (-2146893016)
-#endif // !WEBRTC_WIN
-
-#include "webrtc/base/checks.h"
-#include "webrtc/base/httpbase.h"
-#include "webrtc/base/logging.h"
-#include "webrtc/base/socket.h"
-#include "webrtc/base/stringutils.h"
-#include "webrtc/base/thread.h"
-
-namespace rtc {
-
-//////////////////////////////////////////////////////////////////////
-// Helpers
-//////////////////////////////////////////////////////////////////////
-
-bool MatchHeader(const char* str, size_t len, HttpHeader header) {
- const char* const header_str = ToString(header);
- const size_t header_len = strlen(header_str);
- return (len == header_len) && (_strnicmp(str, header_str, header_len) == 0);
-}
-
-enum {
- MSG_READ
-};
-
-//////////////////////////////////////////////////////////////////////
-// HttpParser
-//////////////////////////////////////////////////////////////////////
-
-HttpParser::HttpParser() {
- reset();
-}
-
-HttpParser::~HttpParser() {
-}
-
-void
-HttpParser::reset() {
- state_ = ST_LEADER;
- chunked_ = false;
- data_size_ = SIZE_UNKNOWN;
-}
-
-HttpParser::ProcessResult
-HttpParser::Process(const char* buffer, size_t len, size_t* processed,
- HttpError* error) {
- *processed = 0;
- *error = HE_NONE;
-
- if (state_ >= ST_COMPLETE) {
- RTC_NOTREACHED();
- return PR_COMPLETE;
- }
-
- while (true) {
- if (state_ < ST_DATA) {
- size_t pos = *processed;
- while ((pos < len) && (buffer[pos] != '\n')) {
- pos += 1;
- }
- if (pos >= len) {
- break; // don't have a full header
- }
- const char* line = buffer + *processed;
- size_t len = (pos - *processed);
- *processed = pos + 1;
- while ((len > 0) && isspace(static_cast<unsigned char>(line[len-1]))) {
- len -= 1;
- }
- ProcessResult result = ProcessLine(line, len, error);
- LOG(LS_VERBOSE) << "Processed line, result=" << result;
-
- if (PR_CONTINUE != result) {
- return result;
- }
- } else if (data_size_ == 0) {
- if (chunked_) {
- state_ = ST_CHUNKTERM;
- } else {
- return PR_COMPLETE;
- }
- } else {
- size_t available = len - *processed;
- if (available <= 0) {
- break; // no more data
- }
- if ((data_size_ != SIZE_UNKNOWN) && (available > data_size_)) {
- available = data_size_;
- }
- size_t read = 0;
- ProcessResult result = ProcessData(buffer + *processed, available, read,
- error);
- LOG(LS_VERBOSE) << "Processed data, result: " << result << " read: "
- << read << " err: " << error;
-
- if (PR_CONTINUE != result) {
- return result;
- }
- *processed += read;
- if (data_size_ != SIZE_UNKNOWN) {
- data_size_ -= read;
- }
- }
- }
-
- return PR_CONTINUE;
-}
-
-HttpParser::ProcessResult
-HttpParser::ProcessLine(const char* line, size_t len, HttpError* error) {
- LOG_F(LS_VERBOSE) << " state: " << state_ << " line: "
- << std::string(line, len) << " len: " << len << " err: "
- << error;
-
- switch (state_) {
- case ST_LEADER:
- state_ = ST_HEADERS;
- return ProcessLeader(line, len, error);
-
- case ST_HEADERS:
- if (len > 0) {
- const char* value = strchrn(line, len, ':');
- if (!value) {
- *error = HE_PROTOCOL;
- return PR_COMPLETE;
- }
- size_t nlen = (value - line);
- const char* eol = line + len;
- do {
- value += 1;
- } while ((value < eol) && isspace(static_cast<unsigned char>(*value)));
- size_t vlen = eol - value;
- if (MatchHeader(line, nlen, HH_CONTENT_LENGTH)) {
- // sscanf isn't safe with strings that aren't null-terminated, and there
- // is no guarantee that |value| is.
- // Create a local copy that is null-terminated.
- std::string value_str(value, vlen);
- unsigned int temp_size;
- if (sscanf(value_str.c_str(), "%u", &temp_size) != 1) {
- *error = HE_PROTOCOL;
- return PR_COMPLETE;
- }
- data_size_ = static_cast<size_t>(temp_size);
- } else if (MatchHeader(line, nlen, HH_TRANSFER_ENCODING)) {
- if ((vlen == 7) && (_strnicmp(value, "chunked", 7) == 0)) {
- chunked_ = true;
- } else if ((vlen == 8) && (_strnicmp(value, "identity", 8) == 0)) {
- chunked_ = false;
- } else {
- *error = HE_PROTOCOL;
- return PR_COMPLETE;
- }
- }
- return ProcessHeader(line, nlen, value, vlen, error);
- } else {
- state_ = chunked_ ? ST_CHUNKSIZE : ST_DATA;
- return ProcessHeaderComplete(chunked_, data_size_, error);
- }
- break;
-
- case ST_CHUNKSIZE:
- if (len > 0) {
- char* ptr = nullptr;
- data_size_ = strtoul(line, &ptr, 16);
- if (ptr != line + len) {
- *error = HE_PROTOCOL;
- return PR_COMPLETE;
- }
- state_ = (data_size_ == 0) ? ST_TRAILERS : ST_DATA;
- } else {
- *error = HE_PROTOCOL;
- return PR_COMPLETE;
- }
- break;
-
- case ST_CHUNKTERM:
- if (len > 0) {
- *error = HE_PROTOCOL;
- return PR_COMPLETE;
- } else {
- state_ = chunked_ ? ST_CHUNKSIZE : ST_DATA;
- }
- break;
-
- case ST_TRAILERS:
- if (len == 0) {
- return PR_COMPLETE;
- }
- // *error = onHttpRecvTrailer();
- break;
-
- default:
- RTC_NOTREACHED();
- break;
- }
-
- return PR_CONTINUE;
-}
-
-bool
-HttpParser::is_valid_end_of_input() const {
- return (state_ == ST_DATA) && (data_size_ == SIZE_UNKNOWN);
-}
-
-void
-HttpParser::complete(HttpError error) {
- if (state_ < ST_COMPLETE) {
- state_ = ST_COMPLETE;
- OnComplete(error);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// HttpBase::DocumentStream
-//////////////////////////////////////////////////////////////////////
-
-class BlockingMemoryStream : public ExternalMemoryStream {
-public:
- BlockingMemoryStream(char* buffer, size_t size)
- : ExternalMemoryStream(buffer, size) { }
-
- StreamResult DoReserve(size_t size, int* error) override {
- return (buffer_length_ >= size) ? SR_SUCCESS : SR_BLOCK;
- }
-};
-
-class HttpBase::DocumentStream : public StreamInterface {
-public:
- DocumentStream(HttpBase* base) : base_(base), error_(HE_DEFAULT) { }
-
- StreamState GetState() const override {
- if (nullptr == base_)
- return SS_CLOSED;
- if (HM_RECV == base_->mode_)
- return SS_OPEN;
- return SS_OPENING;
- }
-
- StreamResult Read(void* buffer,
- size_t buffer_len,
- size_t* read,
- int* error) override {
- if (!base_) {
- if (error) *error = error_;
- return (HE_NONE == error_) ? SR_EOS : SR_ERROR;
- }
-
- if (HM_RECV != base_->mode_) {
- return SR_BLOCK;
- }
-
- // DoReceiveLoop writes http document data to the StreamInterface* document
- // member of HttpData. In this case, we want this data to be written
- // directly to our buffer. To accomplish this, we wrap our buffer with a
- // StreamInterface, and replace the existing document with our wrapper.
- // When the method returns, we restore the old document. Ideally, we would
- // pass our StreamInterface* to DoReceiveLoop, but due to the callbacks
- // of HttpParser, we would still need to store the pointer temporarily.
- std::unique_ptr<StreamInterface> stream(
- new BlockingMemoryStream(reinterpret_cast<char*>(buffer), buffer_len));
-
- // Replace the existing document with our wrapped buffer.
- base_->data_->document.swap(stream);
-
- // Pump the I/O loop. DoReceiveLoop is guaranteed not to attempt to
- // complete the I/O process, which means that our wrapper is not in danger
- // of being deleted. To ensure this, DoReceiveLoop returns true when it
- // wants complete to be called. We make sure to uninstall our wrapper
- // before calling complete().
- HttpError http_error;
- bool complete = base_->DoReceiveLoop(&http_error);
-
- // Reinstall the original output document.
- base_->data_->document.swap(stream);
-
- // If we reach the end of the receive stream, we disconnect our stream
- // adapter from the HttpBase, and further calls to read will either return
- // EOS or ERROR, appropriately. Finally, we call complete().
- StreamResult result = SR_BLOCK;
- if (complete) {
- HttpBase* base = Disconnect(http_error);
- if (error) *error = error_;
- result = (HE_NONE == error_) ? SR_EOS : SR_ERROR;
- base->complete(http_error);
- }
-
- // Even if we are complete, if some data was read we must return SUCCESS.
- // Future Reads will return EOS or ERROR based on the error_ variable.
- size_t position;
- stream->GetPosition(&position);
- if (position > 0) {
- if (read) *read = position;
- result = SR_SUCCESS;
- }
- return result;
- }
-
- StreamResult Write(const void* data,
- size_t data_len,
- size_t* written,
- int* error) override {
- if (error) *error = -1;
- return SR_ERROR;
- }
-
- void Close() override {
- if (base_) {
- HttpBase* base = Disconnect(HE_NONE);
- if (HM_RECV == base->mode_ && base->http_stream_) {
- // Read I/O could have been stalled on the user of this DocumentStream,
- // so restart the I/O process now that we've removed ourselves.
- base->http_stream_->PostEvent(SE_READ, 0);
- }
- }
- }
-
- bool GetAvailable(size_t* size) const override {
- if (!base_ || HM_RECV != base_->mode_)
- return false;
- size_t data_size = base_->GetDataRemaining();
- if (SIZE_UNKNOWN == data_size)
- return false;
- if (size)
- *size = data_size;
- return true;
- }
-
- HttpBase* Disconnect(HttpError error) {
- RTC_DCHECK(nullptr != base_);
- RTC_DCHECK(nullptr != base_->doc_stream_);
- HttpBase* base = base_;
- base_->doc_stream_ = nullptr;
- base_ = nullptr;
- error_ = error;
- return base;
- }
-
-private:
- HttpBase* base_;
- HttpError error_;
-};
-
-//////////////////////////////////////////////////////////////////////
-// HttpBase
-//////////////////////////////////////////////////////////////////////
-
-HttpBase::HttpBase()
- : mode_(HM_NONE),
- data_(nullptr),
- notify_(nullptr),
- http_stream_(nullptr),
- doc_stream_(nullptr) {}
-
-HttpBase::~HttpBase() {
- RTC_DCHECK(HM_NONE == mode_);
-}
-
-bool
-HttpBase::isConnected() const {
- return (http_stream_ != nullptr) && (http_stream_->GetState() == SS_OPEN);
-}
-
-bool
-HttpBase::attach(StreamInterface* stream) {
- if ((mode_ != HM_NONE) || (http_stream_ != nullptr) || (stream == nullptr)) {
- RTC_NOTREACHED();
- return false;
- }
- http_stream_ = stream;
- http_stream_->SignalEvent.connect(this, &HttpBase::OnHttpStreamEvent);
- mode_ = (http_stream_->GetState() == SS_OPENING) ? HM_CONNECT : HM_NONE;
- return true;
-}
-
-StreamInterface*
-HttpBase::detach() {
- RTC_DCHECK(HM_NONE == mode_);
- if (mode_ != HM_NONE) {
- return nullptr;
- }
- StreamInterface* stream = http_stream_;
- http_stream_ = nullptr;
- if (stream) {
- stream->SignalEvent.disconnect(this);
- }
- return stream;
-}
-
-void
-HttpBase::send(HttpData* data) {
- RTC_DCHECK(HM_NONE == mode_);
- if (mode_ != HM_NONE) {
- return;
- } else if (!isConnected()) {
- OnHttpStreamEvent(http_stream_, SE_CLOSE, HE_DISCONNECTED);
- return;
- }
-
- mode_ = HM_SEND;
- data_ = data;
- len_ = 0;
- ignore_data_ = chunk_data_ = false;
-
- if (data_->document) {
- data_->document->SignalEvent.connect(this, &HttpBase::OnDocumentEvent);
- }
-
- std::string encoding;
- if (data_->hasHeader(HH_TRANSFER_ENCODING, &encoding)
- && (encoding == "chunked")) {
- chunk_data_ = true;
- }
-
- len_ = data_->formatLeader(buffer_, sizeof(buffer_));
- len_ += strcpyn(buffer_ + len_, sizeof(buffer_) - len_, "\r\n");
-
- header_ = data_->begin();
- if (header_ == data_->end()) {
- // We must call this at least once, in the case where there are no headers.
- queue_headers();
- }
-
- flush_data();
-}
-
-void
-HttpBase::recv(HttpData* data) {
- RTC_DCHECK(HM_NONE == mode_);
- if (mode_ != HM_NONE) {
- return;
- } else if (!isConnected()) {
- OnHttpStreamEvent(http_stream_, SE_CLOSE, HE_DISCONNECTED);
- return;
- }
-
- mode_ = HM_RECV;
- data_ = data;
- len_ = 0;
- ignore_data_ = chunk_data_ = false;
-
- reset();
- if (doc_stream_) {
- doc_stream_->SignalEvent(doc_stream_, SE_OPEN | SE_READ, 0);
- } else {
- read_and_process_data();
- }
-}
-
-void
-HttpBase::abort(HttpError err) {
- if (mode_ != HM_NONE) {
- if (http_stream_ != nullptr) {
- http_stream_->Close();
- }
- do_complete(err);
- }
-}
-
-StreamInterface* HttpBase::GetDocumentStream() {
- if (doc_stream_)
- return nullptr;
- doc_stream_ = new DocumentStream(this);
- return doc_stream_;
-}
-
-HttpError HttpBase::HandleStreamClose(int error) {
- if (http_stream_ != nullptr) {
- http_stream_->Close();
- }
- if (error == 0) {
- if ((mode_ == HM_RECV) && is_valid_end_of_input()) {
- return HE_NONE;
- } else {
- return HE_DISCONNECTED;
- }
- } else if (error == SOCKET_EACCES) {
- return HE_AUTH;
- } else if (error == SEC_E_CERT_EXPIRED) {
- return HE_CERTIFICATE_EXPIRED;
- }
- LOG_F(LS_ERROR) << "(" << error << ")";
- return (HM_CONNECT == mode_) ? HE_CONNECT_FAILED : HE_SOCKET_ERROR;
-}
-
-bool HttpBase::DoReceiveLoop(HttpError* error) {
- RTC_DCHECK(HM_RECV == mode_);
- RTC_DCHECK(nullptr != error);
-
- // Do to the latency between receiving read notifications from
- // pseudotcpchannel, we rely on repeated calls to read in order to acheive
- // ideal throughput. The number of reads is limited to prevent starving
- // the caller.
-
- size_t loop_count = 0;
- const size_t kMaxReadCount = 20;
- bool process_requires_more_data = false;
- do {
- // The most frequent use of this function is response to new data available
- // on http_stream_. Therefore, we optimize by attempting to read from the
- // network first (as opposed to processing existing data first).
-
- if (len_ < sizeof(buffer_)) {
- // Attempt to buffer more data.
- size_t read;
- int read_error;
- StreamResult read_result = http_stream_->Read(buffer_ + len_,
- sizeof(buffer_) - len_,
- &read, &read_error);
- switch (read_result) {
- case SR_SUCCESS:
- RTC_DCHECK(len_ + read <= sizeof(buffer_));
- len_ += read;
- break;
- case SR_BLOCK:
- if (process_requires_more_data) {
- // We're can't make progress until more data is available.
- return false;
- }
- // Attempt to process the data already in our buffer.
- break;
- case SR_EOS:
- // Clean close, with no error.
- read_error = 0;
- FALLTHROUGH(); // Fall through to HandleStreamClose.
- case SR_ERROR:
- *error = HandleStreamClose(read_error);
- return true;
- }
- } else if (process_requires_more_data) {
- // We have too much unprocessed data in our buffer. This should only
- // occur when a single HTTP header is longer than the buffer size (32K).
- // Anything longer than that is almost certainly an error.
- *error = HE_OVERFLOW;
- return true;
- }
-
- // Process data in our buffer. Process is not guaranteed to process all
- // the buffered data. In particular, it will wait until a complete
- // protocol element (such as http header, or chunk size) is available,
- // before processing it in its entirety. Also, it is valid and sometimes
- // necessary to call Process with an empty buffer, since the state machine
- // may have interrupted state transitions to complete.
- size_t processed;
- ProcessResult process_result = Process(buffer_, len_, &processed,
- error);
- RTC_DCHECK(processed <= len_);
- len_ -= processed;
- memmove(buffer_, buffer_ + processed, len_);
- switch (process_result) {
- case PR_CONTINUE:
- // We need more data to make progress.
- process_requires_more_data = true;
- break;
- case PR_BLOCK:
- // We're stalled on writing the processed data.
- return false;
- case PR_COMPLETE:
- // *error already contains the correct code.
- return true;
- }
- } while (++loop_count <= kMaxReadCount);
-
- LOG_F(LS_WARNING) << "danger of starvation";
- return false;
-}
-
-void
-HttpBase::read_and_process_data() {
- HttpError error;
- if (DoReceiveLoop(&error)) {
- complete(error);
- }
-}
-
-void
-HttpBase::flush_data() {
- RTC_DCHECK(HM_SEND == mode_);
-
- // When send_required is true, no more buffering can occur without a network
- // write.
- bool send_required = (len_ >= sizeof(buffer_));
-
- while (true) {
- RTC_DCHECK(len_ <= sizeof(buffer_));
-
- // HTTP is inherently sensitive to round trip latency, since a frequent use
- // case is for small requests and responses to be sent back and forth, and
- // the lack of pipelining forces a single request to take a minimum of the
- // round trip time. As a result, it is to our benefit to pack as much data
- // into each packet as possible. Thus, we defer network writes until we've
- // buffered as much data as possible.
-
- if (!send_required && (header_ != data_->end())) {
- // First, attempt to queue more header data.
- send_required = queue_headers();
- }
-
- if (!send_required && data_->document) {
- // Next, attempt to queue document data.
-
- const size_t kChunkDigits = 8;
- size_t offset, reserve;
- if (chunk_data_) {
- // Reserve characters at the start for X-byte hex value and \r\n
- offset = len_ + kChunkDigits + 2;
- // ... and 2 characters at the end for \r\n
- reserve = offset + 2;
- } else {
- offset = len_;
- reserve = offset;
- }
-
- if (reserve >= sizeof(buffer_)) {
- send_required = true;
- } else {
- size_t read;
- int error;
- StreamResult result = data_->document->Read(buffer_ + offset,
- sizeof(buffer_) - reserve,
- &read, &error);
- if (result == SR_SUCCESS) {
- RTC_DCHECK(reserve + read <= sizeof(buffer_));
- if (chunk_data_) {
- // Prepend the chunk length in hex.
- // Note: sprintfn appends a null terminator, which is why we can't
- // combine it with the line terminator.
- sprintfn(buffer_ + len_, kChunkDigits + 1, "%.*x",
- kChunkDigits, read);
- // Add line terminator to the chunk length.
- memcpy(buffer_ + len_ + kChunkDigits, "\r\n", 2);
- // Add line terminator to the end of the chunk.
- memcpy(buffer_ + offset + read, "\r\n", 2);
- }
- len_ = reserve + read;
- } else if (result == SR_BLOCK) {
- // Nothing to do but flush data to the network.
- send_required = true;
- } else if (result == SR_EOS) {
- if (chunk_data_) {
- // Append the empty chunk and empty trailers, then turn off
- // chunking.
- RTC_DCHECK(len_ + 5 <= sizeof(buffer_));
- memcpy(buffer_ + len_, "0\r\n\r\n", 5);
- len_ += 5;
- chunk_data_ = false;
- } else if (0 == len_) {
- // No more data to read, and no more data to write.
- do_complete();
- return;
- }
- // Although we are done reading data, there is still data which needs
- // to be flushed to the network.
- send_required = true;
- } else {
- LOG_F(LS_ERROR) << "Read error: " << error;
- do_complete(HE_STREAM);
- return;
- }
- }
- }
-
- if (0 == len_) {
- // No data currently available to send.
- if (!data_->document) {
- // If there is no source document, that means we're done.
- do_complete();
- }
- return;
- }
-
- size_t written;
- int error;
- StreamResult result = http_stream_->Write(buffer_, len_, &written, &error);
- if (result == SR_SUCCESS) {
- RTC_DCHECK(written <= len_);
- len_ -= written;
- memmove(buffer_, buffer_ + written, len_);
- send_required = false;
- } else if (result == SR_BLOCK) {
- if (send_required) {
- // Nothing more we can do until network is writeable.
- return;
- }
- } else {
- RTC_DCHECK(result == SR_ERROR);
- LOG_F(LS_ERROR) << "error";
- OnHttpStreamEvent(http_stream_, SE_CLOSE, error);
- return;
- }
- }
-
- RTC_NOTREACHED();
-}
-
-bool
-HttpBase::queue_headers() {
- RTC_DCHECK(HM_SEND == mode_);
- while (header_ != data_->end()) {
- size_t len = sprintfn(buffer_ + len_, sizeof(buffer_) - len_,
- "%.*s: %.*s\r\n",
- header_->first.size(), header_->first.data(),
- header_->second.size(), header_->second.data());
- if (len_ + len < sizeof(buffer_) - 3) {
- len_ += len;
- ++header_;
- } else if (len_ == 0) {
- LOG(WARNING) << "discarding header that is too long: " << header_->first;
- ++header_;
- } else {
- // Not enough room for the next header, write to network first.
- return true;
- }
- }
- // End of headers
- len_ += strcpyn(buffer_ + len_, sizeof(buffer_) - len_, "\r\n");
- return false;
-}
-
-void
-HttpBase::do_complete(HttpError err) {
- RTC_DCHECK(mode_ != HM_NONE);
- HttpMode mode = mode_;
- mode_ = HM_NONE;
- if (data_ && data_->document) {
- data_->document->SignalEvent.disconnect(this);
- }
- data_ = nullptr;
- if ((HM_RECV == mode) && doc_stream_) {
- RTC_DCHECK(HE_NONE !=
- err); // We should have Disconnected doc_stream_ already.
- DocumentStream* ds = doc_stream_;
- ds->Disconnect(err);
- ds->SignalEvent(ds, SE_CLOSE, err);
- }
- if (notify_) {
- notify_->onHttpComplete(mode, err);
- }
-}
-
-//
-// Stream Signals
-//
-
-void
-HttpBase::OnHttpStreamEvent(StreamInterface* stream, int events, int error) {
- RTC_DCHECK(stream == http_stream_);
- if ((events & SE_OPEN) && (mode_ == HM_CONNECT)) {
- do_complete();
- return;
- }
-
- if ((events & SE_WRITE) && (mode_ == HM_SEND)) {
- flush_data();
- return;
- }
-
- if ((events & SE_READ) && (mode_ == HM_RECV)) {
- if (doc_stream_) {
- doc_stream_->SignalEvent(doc_stream_, SE_READ, 0);
- } else {
- read_and_process_data();
- }
- return;
- }
-
- if ((events & SE_CLOSE) == 0)
- return;
-
- HttpError http_error = HandleStreamClose(error);
- if (mode_ == HM_RECV) {
- complete(http_error);
- } else if (mode_ != HM_NONE) {
- do_complete(http_error);
- } else if (notify_) {
- notify_->onHttpClosed(http_error);
- }
-}
-
-void
-HttpBase::OnDocumentEvent(StreamInterface* stream, int events, int error) {
- RTC_DCHECK(stream == data_->document.get());
- if ((events & SE_WRITE) && (mode_ == HM_RECV)) {
- read_and_process_data();
- return;
- }
-
- if ((events & SE_READ) && (mode_ == HM_SEND)) {
- flush_data();
- return;
- }
-
- if (events & SE_CLOSE) {
- LOG_F(LS_ERROR) << "Read error: " << error;
- do_complete(HE_STREAM);
- return;
- }
-}
-
-//
-// HttpParser Implementation
-//
-
-HttpParser::ProcessResult
-HttpBase::ProcessLeader(const char* line, size_t len, HttpError* error) {
- *error = data_->parseLeader(line, len);
- return (HE_NONE == *error) ? PR_CONTINUE : PR_COMPLETE;
-}
-
-HttpParser::ProcessResult
-HttpBase::ProcessHeader(const char* name, size_t nlen, const char* value,
- size_t vlen, HttpError* error) {
- std::string sname(name, nlen), svalue(value, vlen);
- data_->addHeader(sname, svalue);
- return PR_CONTINUE;
-}
-
-HttpParser::ProcessResult
-HttpBase::ProcessHeaderComplete(bool chunked, size_t& data_size,
- HttpError* error) {
- StreamInterface* old_docstream = doc_stream_;
- if (notify_) {
- *error = notify_->onHttpHeaderComplete(chunked, data_size);
- // The request must not be aborted as a result of this callback.
- RTC_DCHECK(nullptr != data_);
- }
- if ((HE_NONE == *error) && data_->document) {
- data_->document->SignalEvent.connect(this, &HttpBase::OnDocumentEvent);
- }
- if (HE_NONE != *error) {
- return PR_COMPLETE;
- }
- if (old_docstream != doc_stream_) {
- // Break out of Process loop, since our I/O model just changed.
- return PR_BLOCK;
- }
- return PR_CONTINUE;
-}
-
-HttpParser::ProcessResult
-HttpBase::ProcessData(const char* data, size_t len, size_t& read,
- HttpError* error) {
- if (ignore_data_ || !data_->document) {
- read = len;
- return PR_CONTINUE;
- }
- int write_error = 0;
- switch (data_->document->Write(data, len, &read, &write_error)) {
- case SR_SUCCESS:
- return PR_CONTINUE;
- case SR_BLOCK:
- return PR_BLOCK;
- case SR_EOS:
- LOG_F(LS_ERROR) << "Unexpected EOS";
- *error = HE_STREAM;
- return PR_COMPLETE;
- case SR_ERROR:
- default:
- LOG_F(LS_ERROR) << "Write error: " << write_error;
- *error = HE_STREAM;
- return PR_COMPLETE;
- }
-}
-
-void
-HttpBase::OnComplete(HttpError err) {
- LOG_F(LS_VERBOSE);
- do_complete(err);
-}
-
-} // namespace rtc
« no previous file with comments | « webrtc/base/httpbase.h ('k') | webrtc/base/httpbase_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698