Index: webrtc/base/httpbase.cc |
diff --git a/webrtc/base/httpbase.cc b/webrtc/base/httpbase.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..bc8ac64c711c1abb33201c0c281ca38ed4c60aa8 |
--- /dev/null |
+++ b/webrtc/base/httpbase.cc |
@@ -0,0 +1,886 @@ |
+/* |
+ * 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 |