shill: Remove HTTPProxy
This code has been unused for a long time.
BUG=chromium:649417
TEST=shill unit tests
Change-Id: I7d7bdebda771f432543f6dee4ade4b9fc3fcfd9a
Reviewed-on: https://chromium-review.googlesource.com/398300
Commit-Ready: Eric Caruso <ejcaruso@chromium.org>
Tested-by: Eric Caruso <ejcaruso@chromium.org>
Reviewed-by: Kirtika Ruchandani <kirtika@chromium.org>
Reviewed-by: Kevin Cernekee <cernekee@chromium.org>
diff --git a/Android.mk b/Android.mk
index 458c50d..0f7ebc6 100644
--- a/Android.mk
+++ b/Android.mk
@@ -229,7 +229,6 @@
file_reader.cc \
geolocation_info.cc \
hook_table.cc \
- http_proxy.cc \
http_request.cc \
http_url.cc \
icmp.cc \
@@ -451,7 +450,6 @@
fake_store.cc \
file_reader_unittest.cc \
hook_table_unittest.cc \
- http_proxy_unittest.cc \
http_request_unittest.cc \
http_url_unittest.cc \
icmp_unittest.cc \
diff --git a/device.cc b/device.cc
index 45564c2..4641dad 100644
--- a/device.cc
+++ b/device.cc
@@ -53,7 +53,6 @@
#include "shill/error.h"
#include "shill/event_dispatcher.h"
#include "shill/geolocation_info.h"
-#include "shill/http_proxy.h"
#include "shill/icmp.h"
#include "shill/ip_address_store.h"
#include "shill/link_monitor.h"
diff --git a/http_proxy.cc b/http_proxy.cc
deleted file mode 100644
index 7baeb16..0000000
--- a/http_proxy.cc
+++ /dev/null
@@ -1,734 +0,0 @@
-//
-// Copyright (C) 2012 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#include "shill/http_proxy.h"
-
-#include <errno.h>
-#include <netinet/in.h>
-#include <linux/if.h> // NOLINT - Needs definitions from netinet/in.h
-#include <stdio.h>
-#include <time.h>
-
-#include <string>
-#include <vector>
-
-#include <base/bind.h>
-#include <base/strings/string_number_conversions.h>
-#include <base/strings/string_split.h>
-#include <base/strings/string_util.h>
-#include <base/strings/stringprintf.h>
-
-#include "shill/async_connection.h"
-#include "shill/connection.h"
-#include "shill/dns_client.h"
-#include "shill/event_dispatcher.h"
-#include "shill/logging.h"
-#include "shill/net/ip_address.h"
-#include "shill/net/sockets.h"
-
-using base::Bind;
-using base::StringPrintf;
-using std::string;
-using std::vector;
-
-namespace shill {
-
-namespace Logging {
-static auto kModuleLogScope = ScopeLogger::kHTTPProxy;
-static string ObjectID(Connection* c) {
- return c->interface_name();
-}
-}
-
-const int HTTPProxy::kClientHeaderTimeoutSeconds = 1;
-const int HTTPProxy::kConnectTimeoutSeconds = 10;
-const int HTTPProxy::kDNSTimeoutSeconds = 5;
-const int HTTPProxy::kDefaultServerPort = 80;
-const int HTTPProxy::kInputTimeoutSeconds = 30;
-const size_t HTTPProxy::kMaxClientQueue = 10;
-const size_t HTTPProxy::kMaxHeaderCount = 128;
-const size_t HTTPProxy::kMaxHeaderSize = 2048;
-const int HTTPProxy::kTransactionTimeoutSeconds = 600;
-
-const char HTTPProxy::kHTTPMethodConnect[] = "connect";
-const char HTTPProxy::kHTTPMethodTerminator[] = " ";
-const char HTTPProxy::kHTTPURLDelimiters[] = " /#?";
-const char HTTPProxy::kHTTPURLPrefix[] = "http://";
-const char HTTPProxy::kHTTPVersionPrefix[] = " HTTP/1";
-const char HTTPProxy::kInternalErrorMsg[] = "Proxy Failed: Internal Error";
-
-HTTPProxy::HTTPProxy(ConnectionRefPtr connection)
- : state_(kStateIdle),
- connection_(connection),
- weak_ptr_factory_(this),
- accept_callback_(Bind(&HTTPProxy::AcceptClient,
- weak_ptr_factory_.GetWeakPtr())),
- connect_completion_callback_(Bind(&HTTPProxy::OnConnectCompletion,
- weak_ptr_factory_.GetWeakPtr())),
- dns_client_callback_(Bind(&HTTPProxy::GetDNSResult,
- weak_ptr_factory_.GetWeakPtr())),
- read_client_callback_(Bind(&HTTPProxy::ReadFromClient,
- weak_ptr_factory_.GetWeakPtr())),
- read_server_callback_(Bind(&HTTPProxy::ReadFromServer,
- weak_ptr_factory_.GetWeakPtr())),
- write_client_callback_(Bind(&HTTPProxy::WriteToClient,
- weak_ptr_factory_.GetWeakPtr())),
- write_server_callback_(Bind(&HTTPProxy::WriteToServer,
- weak_ptr_factory_.GetWeakPtr())),
- dispatcher_(nullptr),
- proxy_port_(-1),
- proxy_socket_(-1),
- sockets_(nullptr),
- client_socket_(-1),
- server_port_(kDefaultServerPort),
- server_socket_(-1),
- is_route_requested_(false) { }
-
-HTTPProxy::~HTTPProxy() {
- Stop();
-}
-
-bool HTTPProxy::Start(EventDispatcher* dispatcher,
- Sockets* sockets) {
- SLOG(connection_.get(), 3) << "In " << __func__;
-
- if (sockets_) {
- // We are already running.
- return true;
- }
-
- proxy_socket_ = sockets->Socket(PF_INET, SOCK_STREAM, 0);
- if (proxy_socket_ < 0) {
- PLOG(ERROR) << "Failed to open proxy socket";
- return false;
- }
-
- struct sockaddr_in addr;
- socklen_t addrlen = sizeof(addr);
- memset(&addr, 0, sizeof(addr));
- addr.sin_family = AF_INET;
- addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
- if (sockets->Bind(proxy_socket_,
- reinterpret_cast<struct sockaddr*>(&addr),
- sizeof(addr)) < 0 ||
- sockets->GetSockName(proxy_socket_,
- reinterpret_cast<struct sockaddr*>(&addr),
- &addrlen) < 0 ||
- sockets->SetNonBlocking(proxy_socket_) < 0 ||
- sockets->Listen(proxy_socket_, kMaxClientQueue) < 0) {
- sockets->Close(proxy_socket_);
- proxy_socket_ = -1;
- PLOG(ERROR) << "HTTPProxy socket setup failed";
- return false;
- }
-
- accept_handler_.reset(
- dispatcher->CreateReadyHandler(proxy_socket_, IOHandler::kModeInput,
- accept_callback_));
- dispatcher_ = dispatcher;
- dns_client_.reset(new DNSClient(IPAddress::kFamilyIPv4,
- connection_->interface_name(),
- connection_->dns_servers(),
- kDNSTimeoutSeconds * 1000,
- dispatcher,
- dns_client_callback_));
- proxy_port_ = ntohs(addr.sin_port);
- server_async_connection_.reset(
- new AsyncConnection(connection_->interface_name(), dispatcher, sockets,
- connect_completion_callback_));
- sockets_ = sockets;
- state_ = kStateWaitConnection;
- return true;
-}
-
-void HTTPProxy::Stop() {
- SLOG(connection_.get(), 3) << "In " << __func__;
-
- if (!sockets_) {
- return;
- }
-
- StopClient();
-
- accept_handler_.reset();
- dispatcher_ = nullptr;
- dns_client_.reset();
- proxy_port_ = -1;
- server_async_connection_.reset();
- sockets_->Close(proxy_socket_);
- proxy_socket_ = -1;
- sockets_ = nullptr;
- state_ = kStateIdle;
-}
-
-// IOReadyHandler callback routine fired when a client connects to the
-// proxy's socket. We Accept() the client and start reading a request
-// from it.
-void HTTPProxy::AcceptClient(int fd) {
- SLOG(connection_.get(), 3) << "In " << __func__;
-
- int client_fd = sockets_->Accept(fd, nullptr, nullptr);
- if (client_fd < 0) {
- PLOG(ERROR) << "Client accept failed";
- return;
- }
-
- accept_handler_->Stop();
-
- client_socket_ = client_fd;
-
- sockets_->SetNonBlocking(client_socket_);
- read_client_handler_.reset(dispatcher_->CreateInputHandler(
- client_socket_,
- read_client_callback_,
- Bind(&HTTPProxy::OnReadError, weak_ptr_factory_.GetWeakPtr())));
- // Overall transaction timeout.
- transaction_timeout_.Reset(Bind(&HTTPProxy::StopClient,
- weak_ptr_factory_.GetWeakPtr()));
- dispatcher_->PostDelayedTask(transaction_timeout_.callback(),
- kTransactionTimeoutSeconds * 1000);
-
- state_ = kStateReadClientHeader;
- StartIdleTimeout();
-}
-
-bool HTTPProxy::ConnectServer(const IPAddress& address, int port) {
- state_ = kStateConnectServer;
- if (!server_async_connection_->Start(address, port)) {
- SendClientError(500, "Could not create socket to connect to server");
- return false;
- }
- StartIdleTimeout();
- return true;
-}
-
-// DNSClient callback that fires when the DNS request completes.
-void HTTPProxy::GetDNSResult(const Error& error, const IPAddress& address) {
- if (!error.IsSuccess()) {
- SendClientError(502, string("Could not resolve hostname: ") +
- error.message());
- return;
- }
- ConnectServer(address, server_port_);
-}
-
-// IOReadyHandler callback routine which fires when the asynchronous Connect()
-// to the remote server completes (or fails).
-void HTTPProxy::OnConnectCompletion(bool success, int fd) {
- if (!success) {
- SendClientError(500, string("Socket connection delayed failure: ") +
- server_async_connection_->error());
- return;
- }
- server_socket_ = fd;
- state_ = kStateTunnelData;
-
- // If this was a "CONNECT" request, notify the client that the connection
- // has been established by sending an "OK" response.
- if (base::LowerCaseEqualsASCII(client_method_, kHTTPMethodConnect)) {
- SetClientResponse(200, "OK", "", "");
- StartReceive();
- }
-
- StartTransmit();
-}
-
-void HTTPProxy::OnReadError(const string& error_msg) {
- StopClient();
-}
-
-// Read through the header lines from the client, modifying or adding
-// lines as necessary. Perform final determination of the hostname/port
-// we should connect to and either start a DNS request or connect to a
-// numeric address.
-bool HTTPProxy::ParseClientRequest() {
- SLOG(connection_.get(), 3) << "In " << __func__;
-
- string host;
- bool found_via = false;
- bool found_connection = false;
- for (auto& header : client_headers_) {
- if (base::StartsWith(header, "Host:",
- base::CompareCase::INSENSITIVE_ASCII)) {
- host = header.substr(5);
- } else if (base::StartsWith(header, "Via:",
- base::CompareCase::INSENSITIVE_ASCII)) {
- found_via = true;
- header.append(StringPrintf(", %s shill-proxy", client_version_.c_str()));
- } else if (base::StartsWith(header, "Connection:",
- base::CompareCase::INSENSITIVE_ASCII)) {
- found_connection = true;
- header.assign("Connection: close");
- } else if (base::StartsWith(header, "Proxy-Connection:",
- base::CompareCase::INSENSITIVE_ASCII)) {
- header.assign("Proxy-Connection: close");
- }
- }
-
- if (!found_connection) {
- client_headers_.push_back("Connection: close");
- }
- if (!found_via) {
- client_headers_.push_back(
- StringPrintf("Via: %s shill-proxy", client_version_.c_str()));
- }
-
- // Assemble the request as it will be sent to the server.
- client_data_.Clear();
- if (!base::LowerCaseEqualsASCII(client_method_, kHTTPMethodConnect)) {
- for (const auto& header : client_headers_) {
- client_data_.Append(ByteString(header + "\r\n", false));
- }
- client_data_.Append(ByteString(string("\r\n"), false));
- }
-
- base::TrimWhitespaceASCII(host, base::TRIM_ALL, &host);
- if (host.empty()) {
- // Revert to using the hostname in the URL if no "Host:" header exists.
- host = server_hostname_;
- }
-
- if (host.empty()) {
- SendClientError(400, "I don't know what host you want me to connect to");
- return false;
- }
-
- server_port_ = 80;
- vector<string> host_parts = base::SplitString(
- host, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
-
- if (host_parts.size() > 2) {
- SendClientError(400, "Too many colons in hostname");
- return false;
- } else if (host_parts.size() == 2) {
- server_hostname_ = host_parts[0];
- if (!base::StringToInt(host_parts[1], &server_port_)) {
- SendClientError(400, "Could not parse port number");
- return false;
- }
- } else {
- server_hostname_ = host;
- }
-
- connection_->RequestRouting();
- is_route_requested_ = true;
-
- IPAddress addr(IPAddress::kFamilyIPv4);
- if (addr.SetAddressFromString(server_hostname_)) {
- if (!ConnectServer(addr, server_port_)) {
- return false;
- }
- } else {
- SLOG(connection_.get(), 3) << "Looking up host: " << server_hostname_;
- Error error;
- if (!dns_client_->Start(server_hostname_, &error)) {
- SendClientError(502, "Could not resolve hostname: " + error.message());
- return false;
- }
- state_ = kStateLookupServer;
- }
- return true;
-}
-
-// Accept a new line into the client headers. Returns false if a parse
-// error occurs.
-bool HTTPProxy::ProcessLastHeaderLine() {
- string* header = &client_headers_.back();
- base::TrimString(*header, "\r", header);
-
- if (header->empty()) {
- // Empty line terminates client headers.
- client_headers_.pop_back();
- if (!ParseClientRequest()) {
- return false;
- }
- }
-
- // Is this is the first header line?
- if (client_headers_.size() == 1) {
- if (!ReadClientHTTPMethod(header) ||
- !ReadClientHTTPVersion(header) ||
- !ReadClientHostname(header)) {
- return false;
- }
- }
-
- if (client_headers_.size() >= kMaxHeaderCount) {
- SendClientError(500, kInternalErrorMsg);
- return false;
- }
-
- return true;
-}
-
-// Split input from client into header lines, and consume parsed lines
-// from InputData. The passed in |data| is modified to indicate the
-// characters consumed.
-bool HTTPProxy::ReadClientHeaders(InputData* data) {
- unsigned char* ptr = data->buf;
- unsigned char* end = ptr + data->len;
-
- if (client_headers_.empty()) {
- client_headers_.push_back(string());
- }
-
- for (; ptr < end && state_ == kStateReadClientHeader; ++ptr) {
- if (*ptr == '\n') {
- if (!ProcessLastHeaderLine()) {
- return false;
- }
-
- // Start a new line. New chararacters we receive will be appended there.
- client_headers_.push_back(string());
- continue;
- }
-
- string* header = &client_headers_.back();
- // Is the first character of the header line a space or tab character?
- if (header->empty() && (*ptr == ' ' || *ptr == '\t') &&
- client_headers_.size() > 1) {
- // Line Continuation: Add this character to the previous header line.
- // This way, all of the data (including newlines and line continuation
- // characters) related to a specific header will be contained within
- // a single element of |client_headers_|, and manipulation of headers
- // such as appending will be simpler. This is accomplished by removing
- // the empty line we started, and instead appending the whitespace
- // and following characters to the previous line.
- client_headers_.pop_back();
- header = &client_headers_.back();
- header->append("\r\n");
- }
-
- if (header->length() >= kMaxHeaderSize) {
- SendClientError(500, kInternalErrorMsg);
- return false;
- }
- header->push_back(*ptr);
- }
-
- // Return the remaining data to the caller -- this could be POST data
- // or other non-header data sent with the client request.
- data->buf = ptr;
- data->len = end - ptr;
-
- return true;
-}
-
-// Finds the URL in the first line of an HTTP client header, and extracts
-// and removes the hostname (and port) from the URL. Returns false if a
-// parse error occurs, and true otherwise (whether or not the hostname was
-// found).
-bool HTTPProxy::ReadClientHostname(string* header) {
- const string http_url_prefix(kHTTPURLPrefix);
- size_t url_idx = header->find(http_url_prefix);
- if (url_idx != string::npos) {
- size_t host_start = url_idx + http_url_prefix.length();
- size_t host_end =
- header->find_first_of(kHTTPURLDelimiters, host_start);
- if (host_end != string::npos) {
- server_hostname_ = header->substr(host_start,
- host_end - host_start);
- // Modify the URL passed upstream to remove "http://<hostname>".
- header->erase(url_idx, host_end - url_idx);
- if ((*header)[url_idx] != '/') {
- header->insert(url_idx, "/");
- }
- } else {
- LOG(ERROR) << "Could not find end of hostname in request. Line was: "
- << *header;
- SendClientError(500, kInternalErrorMsg);
- return false;
- }
- }
- return true;
-}
-
-bool HTTPProxy::ReadClientHTTPMethod(string* header) {
- size_t method_end = header->find(kHTTPMethodTerminator);
- if (method_end == string::npos || method_end == 0) {
- LOG(ERROR) << "Could not parse HTTP method. Line was: " << *header;
- SendClientError(501, "Server could not parse HTTP method");
- return false;
- }
- client_method_ = header->substr(0, method_end);
- return true;
-}
-
-// Extract the HTTP version number from the first line of the client headers.
-// Returns true if found.
-bool HTTPProxy::ReadClientHTTPVersion(string* header) {
- const string http_version_prefix(kHTTPVersionPrefix);
- size_t http_ver_pos = header->find(http_version_prefix);
- if (http_ver_pos != string::npos) {
- client_version_ =
- header->substr(http_ver_pos + http_version_prefix.length() - 1);
- } else {
- SendClientError(501, "Server only accepts HTTP/1.x requests");
- return false;
- }
- return true;
-}
-
-// IOInputHandler callback that fires when data is read from the client.
-// This could be header data, or perhaps POST data that follows the headers.
-void HTTPProxy::ReadFromClient(InputData* data) {
- SLOG(connection_.get(), 3) << "In " << __func__ << " length " << data->len;
-
- if (data->len < 0) {
- // Read error from client, error callback has already stopped the client.
- return;
- }
-
- if (data->len == 0) {
- // EOF from client.
- StopClient();
- return;
- }
-
- if (state_ == kStateReadClientHeader) {
- if (!ReadClientHeaders(data)) {
- return;
- }
- if (state_ == kStateReadClientHeader) {
- // Still consuming client headers; restart the input timer.
- StartIdleTimeout();
- return;
- }
- }
-
- // Check data->len again since ReadClientHeaders() may have consumed some
- // part of it.
- if (data->len != 0) {
- // The client sent some information after its headers. Buffer the client
- // input and temporarily disable input events from the client.
- client_data_.Append(ByteString(data->buf, data->len));
- read_client_handler_->Stop();
- StartTransmit();
- }
-}
-
-// IOInputHandler callback which fires when data has been read from the
-// server.
-void HTTPProxy::ReadFromServer(InputData* data) {
- SLOG(connection_.get(), 3) << "In " << __func__ << " length " << data->len;
- if (data->len == 0) {
- // Server closed connection.
- if (server_data_.IsEmpty()) {
- StopClient();
- return;
- }
- state_ = kStateFlushResponse;
- } else {
- read_server_handler_->Stop();
- }
-
- server_data_.Append(ByteString(data->buf, data->len));
-
- StartTransmit();
-}
-
-// Return an HTTP error message back to the client.
-void HTTPProxy::SendClientError(int code, const string& error) {
- SLOG(connection_.get(), 3) << "In " << __func__;
- LOG(ERROR) << "Sending error " << error;
- SetClientResponse(code, "ERROR", "text/plain", error);
- state_ = kStateFlushResponse;
- StartTransmit();
-}
-
-// Create an HTTP response message to be sent to the client.
-void HTTPProxy::SetClientResponse(int code, const string& type,
- const string& content_type,
- const string& message) {
- string content_line;
- if (!message.empty() && !content_type.empty()) {
- content_line = StringPrintf("Content-Type: %s\r\n", content_type.c_str());
- }
- string response = StringPrintf("HTTP/1.1 %d %s\r\n"
- "%s\r\n"
- "%s", code, type.c_str(),
- content_line.c_str(),
- message.c_str());
- server_data_ = ByteString(response, false);
-}
-
-// Start a timeout for "the next event". This timeout augments the overall
-// transaction timeout to make sure there is some activity occurring at
-// reasonable intervals.
-void HTTPProxy::StartIdleTimeout() {
- int timeout_seconds = 0;
- switch (state_) {
- case kStateReadClientHeader:
- timeout_seconds = kClientHeaderTimeoutSeconds;
- break;
- case kStateConnectServer:
- timeout_seconds = kConnectTimeoutSeconds;
- break;
- case kStateLookupServer:
- // DNSClient has its own internal timeout, so we need not set one here.
- timeout_seconds = 0;
- break;
- default:
- timeout_seconds = kInputTimeoutSeconds;
- break;
- }
- idle_timeout_.Cancel();
- if (timeout_seconds != 0) {
- idle_timeout_.Reset(Bind(&HTTPProxy::StopClient,
- weak_ptr_factory_.GetWeakPtr()));
- dispatcher_->PostDelayedTask(idle_timeout_.callback(),
- timeout_seconds * 1000);
- }
-}
-
-// Start the various input handlers. Listen for new data only if we have
-// completely written the last data we've received to the other end.
-void HTTPProxy::StartReceive() {
- if (state_ == kStateTunnelData && client_data_.IsEmpty()) {
- read_client_handler_->Start();
- }
- if (server_data_.IsEmpty()) {
- if (state_ == kStateTunnelData) {
- if (read_server_handler_.get()) {
- read_server_handler_->Start();
- } else {
- read_server_handler_.reset(dispatcher_->CreateInputHandler(
- server_socket_,
- read_server_callback_,
- Bind(&HTTPProxy::OnReadError, weak_ptr_factory_.GetWeakPtr())));
- }
- } else if (state_ == kStateFlushResponse) {
- StopClient();
- return;
- }
- }
- StartIdleTimeout();
-}
-
-// Start the various output-ready handlers for the endpoints we have
-// data waiting for.
-void HTTPProxy::StartTransmit() {
- if (state_ == kStateTunnelData && !client_data_.IsEmpty()) {
- if (write_server_handler_.get()) {
- write_server_handler_->Start();
- } else {
- write_server_handler_.reset(
- dispatcher_->CreateReadyHandler(server_socket_,
- IOHandler::kModeOutput,
- write_server_callback_));
- }
- }
- if ((state_ == kStateFlushResponse || state_ == kStateTunnelData) &&
- !server_data_.IsEmpty()) {
- if (write_client_handler_.get()) {
- write_client_handler_->Start();
- } else {
- write_client_handler_.reset(
- dispatcher_->CreateReadyHandler(client_socket_,
- IOHandler::kModeOutput,
- write_client_callback_));
- }
- }
- StartIdleTimeout();
-}
-
-// End the transaction with the current client, restart the IOHandler
-// which alerts us to new clients connecting. This function is called
-// during various error conditions and is a callback for all timeouts.
-void HTTPProxy::StopClient() {
- SLOG(connection_.get(), 3) << "In " << __func__;
-
- if (is_route_requested_) {
- connection_->ReleaseRouting();
- is_route_requested_ = false;
- }
- write_client_handler_.reset();
- read_client_handler_.reset();
- if (client_socket_ != -1) {
- sockets_->Close(client_socket_);
- client_socket_ = -1;
- }
- client_headers_.clear();
- client_method_.clear();
- client_version_.clear();
- server_port_ = kDefaultServerPort;
- write_server_handler_.reset();
- read_server_handler_.reset();
- if (server_socket_ != -1) {
- sockets_->Close(server_socket_);
- server_socket_ = -1;
- }
- server_hostname_.clear();
- client_data_.Clear();
- server_data_.Clear();
- dns_client_->Stop();
- server_async_connection_->Stop();
- idle_timeout_.Cancel();
- transaction_timeout_.Cancel();
- accept_handler_->Start();
- state_ = kStateWaitConnection;
-}
-
-// Output ReadyHandler callback which fires when the client socket is
-// ready for data to be sent to it.
-void HTTPProxy::WriteToClient(int fd) {
- CHECK_EQ(client_socket_, fd);
- int ret = sockets_->Send(fd, server_data_.GetConstData(),
- server_data_.GetLength(), 0);
- SLOG(connection_.get(), 3) << "In " << __func__ << " wrote " << ret << " of "
- << server_data_.GetLength();
- if (ret < 0) {
- LOG(ERROR) << "Server write failed";
- StopClient();
- return;
- }
-
- server_data_ = ByteString(server_data_.GetConstData() + ret,
- server_data_.GetLength() - ret);
-
- if (server_data_.IsEmpty()) {
- write_client_handler_->Stop();
- }
-
- StartReceive();
-}
-
-// Output ReadyHandler callback which fires when the server socket is
-// ready for data to be sent to it.
-void HTTPProxy::WriteToServer(int fd) {
- CHECK_EQ(server_socket_, fd);
- int ret = sockets_->Send(fd, client_data_.GetConstData(),
- client_data_.GetLength(), 0);
- SLOG(connection_.get(), 3) << "In " << __func__ << " wrote " << ret << " of "
- << client_data_.GetLength();
-
- if (ret < 0) {
- LOG(ERROR) << "Client write failed";
- StopClient();
- return;
- }
-
- client_data_ = ByteString(client_data_.GetConstData() + ret,
- client_data_.GetLength() - ret);
-
- if (client_data_.IsEmpty()) {
- write_server_handler_->Stop();
- }
-
- StartReceive();
-}
-
-} // namespace shill
diff --git a/http_proxy.h b/http_proxy.h
deleted file mode 100644
index b4132c6..0000000
--- a/http_proxy.h
+++ /dev/null
@@ -1,175 +0,0 @@
-//
-// Copyright (C) 2012 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef SHILL_HTTP_PROXY_H_
-#define SHILL_HTTP_PROXY_H_
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include <base/cancelable_callback.h>
-#include <base/memory/ref_counted.h>
-#include <base/memory/weak_ptr.h>
-
-#include "shill/net/byte_string.h"
-#include "shill/refptr_types.h"
-
-namespace shill {
-
-class AsyncConnection;
-class DNSClient;
-class Error;
-class EventDispatcher;
-struct InputData;
-class IOHandler;
-class IPAddress;
-class Sockets;
-
-// The HTTPProxy class implements a simple web proxy that
-// is bound to a specific interface and name server. This
-// allows us to specify which connection a URL should be
-// fetched through, even though many connections
-// could be active at the same time.
-//
-// This service is meant to be low-performance, since we
-// do not want to divert resources from the rest of the
-// connection manager. As such, we serve one client request
-// at a time. This is probably okay since the use case is
-// limited -- only portal detection, activation and Cashew
-// are planned to be full-time users.
-class HTTPProxy {
- public:
- enum State {
- kStateIdle,
- kStateWaitConnection,
- kStateReadClientHeader,
- kStateLookupServer,
- kStateConnectServer,
- kStateTunnelData,
- kStateFlushResponse,
- };
-
- explicit HTTPProxy(ConnectionRefPtr connection);
- virtual ~HTTPProxy();
-
- // Start HTTP proxy.
- bool Start(EventDispatcher* dispatcher, Sockets* sockets);
-
- // Shutdown.
- void Stop();
-
- int proxy_port() const { return proxy_port_; }
-
- private:
- friend class HTTPProxyTest;
-
- // Time to wait for initial headers from client.
- static const int kClientHeaderTimeoutSeconds;
- // Time to wait for connection to remote server.
- static const int kConnectTimeoutSeconds;
- // Time to wait for DNS server.
- static const int kDNSTimeoutSeconds;
- // Default port on remote server to connect to.
- static const int kDefaultServerPort;
- // Time to wait for any input from either server or client.
- static const int kInputTimeoutSeconds;
- // Maximum clients to be kept waiting.
- static const size_t kMaxClientQueue;
- // Maximum number of header lines to accept.
- static const size_t kMaxHeaderCount;
- // Maximum length of an individual header line.
- static const size_t kMaxHeaderSize;
- // Timeout for whole transaction.
- static const int kTransactionTimeoutSeconds;
-
- static const char kHTTPMethodConnect[];
- static const char kHTTPMethodTerminator[];
- static const char kHTTPURLDelimiters[];
- static const char kHTTPURLPrefix[];
- static const char kHTTPVersionPrefix[];
- static const char kHTTPVersionErrorMsg[];
- static const char kInternalErrorMsg[]; // Message to send on failure.
-
- void AcceptClient(int fd);
- bool ConnectServer(const IPAddress& address, int port);
- void GetDNSResult(const Error& error, const IPAddress& address);
- void OnReadError(const std::string& error_msg);
- void OnConnectCompletion(bool success, int fd);
- bool ParseClientRequest();
- bool ProcessLastHeaderLine();
- bool ReadClientHeaders(InputData* data);
- bool ReadClientHostname(std::string* header);
- bool ReadClientHTTPMethod(std::string* header);
- bool ReadClientHTTPVersion(std::string* header);
- void ReadFromClient(InputData* data);
- void ReadFromServer(InputData* data);
- void SetClientResponse(int code, const std::string& type,
- const std::string& content_type,
- const std::string& message);
- void SendClientError(int code, const std::string& error);
- void StartIdleTimeout();
- void StartReceive();
- void StartTransmit();
- void StopClient();
- void WriteToClient(int fd);
- void WriteToServer(int fd);
-
- // State held for the lifetime of the proxy.
- State state_;
- ConnectionRefPtr connection_;
- base::WeakPtrFactory<HTTPProxy> weak_ptr_factory_;
- base::Callback<void(int)> accept_callback_;
- base::Callback<void(bool, int)> connect_completion_callback_;
- base::Callback<void(const Error&, const IPAddress&)> dns_client_callback_;
- base::Callback<void(InputData*)> read_client_callback_;
- base::Callback<void(InputData*)> read_server_callback_;
- base::Callback<void(int)> write_client_callback_;
- base::Callback<void(int)> write_server_callback_;
-
- // State held while proxy is started (even if no transaction is active).
- std::unique_ptr<IOHandler> accept_handler_;
- EventDispatcher* dispatcher_;
- std::unique_ptr<DNSClient> dns_client_;
- int proxy_port_;
- int proxy_socket_;
- std::unique_ptr<AsyncConnection> server_async_connection_;
- Sockets* sockets_;
-
- // State held while proxy is started and a transaction is active.
- int client_socket_;
- std::string client_method_;
- std::string client_version_;
- int server_port_;
- int server_socket_;
- bool is_route_requested_;
- base::CancelableClosure idle_timeout_;
- base::CancelableClosure transaction_timeout_;
- std::vector<std::string> client_headers_;
- std::string server_hostname_;
- ByteString client_data_;
- ByteString server_data_;
- std::unique_ptr<IOHandler> read_client_handler_;
- std::unique_ptr<IOHandler> write_client_handler_;
- std::unique_ptr<IOHandler> read_server_handler_;
- std::unique_ptr<IOHandler> write_server_handler_;
-
- DISALLOW_COPY_AND_ASSIGN(HTTPProxy);
-};
-
-} // namespace shill
-
-#endif // SHILL_HTTP_PROXY_H_
diff --git a/http_proxy_unittest.cc b/http_proxy_unittest.cc
deleted file mode 100644
index 3457d4f..0000000
--- a/http_proxy_unittest.cc
+++ /dev/null
@@ -1,856 +0,0 @@
-//
-// Copyright (C) 2012 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#include "shill/http_proxy.h"
-
-#include <netinet/in.h>
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include <base/strings/stringprintf.h>
-#include <gtest/gtest.h>
-
-#include "shill/mock_async_connection.h"
-#include "shill/mock_connection.h"
-#include "shill/mock_control.h"
-#include "shill/mock_device_info.h"
-#include "shill/mock_dns_client.h"
-#include "shill/mock_event_dispatcher.h"
-#include "shill/net/ip_address.h"
-#include "shill/net/mock_sockets.h"
-
-using base::StringPrintf;
-using std::string;
-using std::vector;
-using ::testing::_;
-using ::testing::AnyNumber;
-using ::testing::AtLeast;
-using ::testing::DoAll;
-using ::testing::Invoke;
-using ::testing::NiceMock;
-using ::testing::Return;
-using ::testing::ReturnArg;
-using ::testing::ReturnNew;
-using ::testing::ReturnRef;
-using ::testing::SetArgumentPointee;
-using ::testing::StrEq;
-using ::testing::StrictMock;
-using ::testing::Test;
-
-namespace shill {
-
-namespace {
-const char kBadHeaderMissingURL[] = "BLAH\r\n";
-const char kBadHeaderMissingVersion[] = "BLAH http://hostname\r\n";
-const char kBadHostnameLine[] = "GET HTTP/1.1 http://hostname\r\n";
-const char kBasicGetHeader[] = "GET / HTTP/1.1\r\n";
-const char kBasicGetHeaderWithURL[] =
- "GET http://www.chromium.org/ HTTP/1.1\r\n";
-const char kBasicGetHeaderWithURLNoTrailingSlash[] =
- "GET http://www.chromium.org HTTP/1.1\r\n";
-const char kConnectQuery[] =
- "CONNECT 10.10.10.10:443 HTTP/1.1\r\n"
- "Host: 10.10.10.10:443\r\n\r\n";
-const char kQueryTemplate[] = "GET %s HTTP/%s\r\n%s"
- "User-Agent: Mozilla/5.0 (X11; CrOS i686 1299.0.2011) "
- "AppleWebKit/535.8 (KHTML, like Gecko) Chrome/17.0.936.0 Safari/535.8\r\n"
- "Accept: text/html,application/xhtml+xml,application/xml;"
- "q=0.9,*/*;q=0.8\r\n"
- "Accept-Encoding: gzip,deflate,sdch\r\n"
- "Accept-Language: en-US,en;q=0.8,ja;q=0.6\r\n"
- "Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.3\r\n"
- "Cookie: PREF=ID=xxxxxxxxxxxxxxxx:U=xxxxxxxxxxxxxxxx:FF=0:"
- "TM=1317340083:LM=1317390705:GM=1:S=_xxxxxxxxxxxxxxx; "
- "NID=52=xxxxxxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
- "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx_xxxxxxxxxxxxxxxxxxxxxxx; "
- "HSID=xxxxxxxxxxxx-xxxx; APISID=xxxxxxxxxxxxxxxx/xxxxxxxxxxxxxxxxx; "
- "SID=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx_xxxxxxxxxxx"
- "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxx"
- "xxx_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxxxx"
- "_xxxxx-xxxxxxxxxxxxxxxxxxxxxxxxxx-xx-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
- "xxxxxxxxxxxxxxxx\r\n\r\n";
-const char kInterfaceName[] = "int0";
-const char kDNSServer0[] = "8.8.8.8";
-const char kDNSServer1[] = "8.8.4.4";
-const char kServerAddress[] = "10.10.10.10";
-const char* kDNSServers[] = { kDNSServer0, kDNSServer1 };
-const int kProxyFD = 10203;
-const int kServerFD = 10204;
-const int kClientFD = 10205;
-const int kServerPort = 40506;
-const int kConnectPort = 443;
-} // namespace
-
-MATCHER_P(IsIPAddress, address, "") {
- IPAddress ip_address(IPAddress::kFamilyIPv4);
- EXPECT_TRUE(ip_address.SetAddressFromString(address));
- return ip_address.Equals(arg);
-}
-
-MATCHER_P(CallbackEq, callback, "") {
- return arg.Equals(callback);
-}
-
-class HTTPProxyTest : public Test {
- public:
- HTTPProxyTest()
- : interface_name_(kInterfaceName),
- server_async_connection_(nullptr),
- dns_servers_(kDNSServers, kDNSServers + 2),
- dns_client_(nullptr),
- device_info_(
- new NiceMock<MockDeviceInfo>(&control_, nullptr, nullptr, nullptr)),
- connection_(new StrictMock<MockConnection>(device_info_.get())),
- proxy_(connection_) {}
-
- protected:
- virtual void SetUp() {
- EXPECT_CALL(*connection_.get(), interface_name())
- .WillRepeatedly(ReturnRef(interface_name_));
- EXPECT_CALL(*connection_.get(), dns_servers())
- .WillRepeatedly(ReturnRef(dns_servers_));
- }
- virtual void TearDown() {
- if (proxy_.sockets_) {
- ExpectStop();
- }
- const int proxy_fds[] = {
- proxy_.client_socket_,
- proxy_.server_socket_,
- proxy_.proxy_socket_
- };
- for (const int fd : proxy_fds) {
- if (fd != -1) {
- EXPECT_CALL(sockets_, Close(fd));
- }
- }
- }
- string CreateRequest(const string& url, const string& http_version,
- const string& extra_lines) {
- string append_lines(extra_lines);
- if (append_lines.size()) {
- append_lines.append("\r\n");
- }
- return StringPrintf(kQueryTemplate, url.c_str(), http_version.c_str(),
- append_lines.c_str());
- }
- int InvokeGetSockName(int fd, struct sockaddr* addr_out,
- socklen_t* sockaddr_size) {
- struct sockaddr_in addr;
- EXPECT_EQ(kProxyFD, fd);
- EXPECT_GE(sizeof(sockaddr_in), *sockaddr_size);
- addr.sin_addr.s_addr = 0;
- addr.sin_port = kServerPort;
- memcpy(addr_out, &addr, sizeof(addr));
- *sockaddr_size = sizeof(sockaddr_in);
- return 0;
- }
- void InvokeSyncConnect(const IPAddress& /*address*/, int /*port*/) {
- proxy_.OnConnectCompletion(true, kServerFD);
- }
- size_t FindInRequest(const string& find_string) {
- const ByteString& request_data = GetClientData();
- string request_string(
- reinterpret_cast<const char*>(request_data.GetConstData()),
- request_data.GetLength());
- return request_string.find(find_string);
- }
- // Accessors
- const ByteString& GetClientData() {
- return proxy_.client_data_;
- }
- HTTPProxy* proxy() { return &proxy_; }
- HTTPProxy::State GetProxyState() {
- return proxy_.state_;
- }
- const ByteString& GetServerData() {
- return proxy_.server_data_;
- }
- MockSockets& sockets() { return sockets_; }
- MockEventDispatcher& dispatcher() { return dispatcher_; }
-
-
- // Expectations
- void ExpectClientReset() {
- EXPECT_EQ(-1, proxy_.client_socket_);
- EXPECT_TRUE(proxy_.client_version_.empty());
- EXPECT_EQ(HTTPProxy::kDefaultServerPort, proxy_.server_port_);
- EXPECT_EQ(-1, proxy_.server_socket_);
- EXPECT_TRUE(proxy_.idle_timeout_.IsCancelled());
- EXPECT_TRUE(proxy_.client_headers_.empty());
- EXPECT_TRUE(proxy_.server_hostname_.empty());
- EXPECT_TRUE(proxy_.client_data_.IsEmpty());
- EXPECT_TRUE(proxy_.server_data_.IsEmpty());
- EXPECT_FALSE(proxy_.read_client_handler_.get());
- EXPECT_FALSE(proxy_.write_client_handler_.get());
- EXPECT_FALSE(proxy_.read_server_handler_.get());
- EXPECT_FALSE(proxy_.write_server_handler_.get());
- EXPECT_FALSE(proxy_.is_route_requested_);
- }
- void ExpectReset() {
- EXPECT_FALSE(proxy_.accept_handler_.get());
- EXPECT_EQ(proxy_.connection_.get(), connection_.get());
- EXPECT_FALSE(proxy_.dispatcher_);
- EXPECT_FALSE(proxy_.dns_client_.get());
- EXPECT_EQ(-1, proxy_.proxy_port_);
- EXPECT_EQ(-1, proxy_.proxy_socket_);
- EXPECT_FALSE(proxy_.server_async_connection_.get());
- EXPECT_FALSE(proxy_.sockets_);
- EXPECT_EQ(HTTPProxy::kStateIdle, proxy_.state_);
- ExpectClientReset();
- }
- void ExpectStart() {
- EXPECT_CALL(sockets(), Socket(_, _, _))
- .WillOnce(Return(kProxyFD));
- EXPECT_CALL(sockets(), Bind(kProxyFD, _, _))
- .WillOnce(Return(0));
- EXPECT_CALL(sockets(), GetSockName(kProxyFD, _, _))
- .WillOnce(Invoke(this, &HTTPProxyTest::InvokeGetSockName));
- EXPECT_CALL(sockets(), SetNonBlocking(kProxyFD))
- .WillOnce(Return(0));
- EXPECT_CALL(sockets(), Listen(kProxyFD, _))
- .WillOnce(Return(0));
- EXPECT_CALL(dispatcher_,
- CreateReadyHandler(kProxyFD,
- IOHandler::kModeInput,
- CallbackEq(proxy_.accept_callback_)))
- .WillOnce(ReturnNew<IOHandler>());
- }
- void ExpectStop() {
- if (dns_client_) {
- EXPECT_CALL(*dns_client_, Stop())
- .Times(AtLeast(1));
- }
- if (server_async_connection_) {
- EXPECT_CALL(*server_async_connection_, Stop())
- .Times(AtLeast(1));
- }
- if (proxy_.is_route_requested_) {
- EXPECT_CALL(*connection_.get(), ReleaseRouting());
- }
- }
- void ExpectClientInput(int fd) {
- EXPECT_CALL(sockets(), Accept(kProxyFD, _, _))
- .WillOnce(Return(fd));
- EXPECT_CALL(sockets(), SetNonBlocking(fd))
- .WillOnce(Return(0));
- EXPECT_CALL(dispatcher(),
- CreateInputHandler(fd,
- CallbackEq(proxy_.read_client_callback_), _))
- .WillOnce(ReturnNew<IOHandler>());
- ExpectTransactionTimeout();
- ExpectClientHeaderTimeout();
- }
- void ExpectTimeout(int timeout) {
- EXPECT_CALL(dispatcher_, PostDelayedTask(_, timeout * 1000));
- }
- void ExpectClientHeaderTimeout() {
- ExpectTimeout(HTTPProxy::kClientHeaderTimeoutSeconds);
- }
- void ExpectConnectTimeout() {
- ExpectTimeout(HTTPProxy::kConnectTimeoutSeconds);
- }
- void ExpectInputTimeout() {
- ExpectTimeout(HTTPProxy::kInputTimeoutSeconds);
- }
- void ExpectRepeatedInputTimeout() {
- EXPECT_CALL(dispatcher_,
- PostDelayedTask(_, HTTPProxy::kInputTimeoutSeconds * 1000))
- .Times(AnyNumber());
- }
- void ExpectTransactionTimeout() {
- ExpectTimeout(HTTPProxy::kTransactionTimeoutSeconds);
- }
- void ExpectInClientResponse(const string& response_data) {
- string server_data(reinterpret_cast<char*>(proxy_.server_data_.GetData()),
- proxy_.server_data_.GetLength());
- EXPECT_NE(string::npos, server_data.find(response_data));
- }
- void ExpectClientError(int code, const string& error) {
- EXPECT_EQ(HTTPProxy::kStateFlushResponse, GetProxyState());
- string status_line = StringPrintf("HTTP/1.1 %d ERROR", code);
- ExpectInClientResponse(status_line);
- ExpectInClientResponse(error);
- }
- void ExpectClientInternalError() {
- ExpectClientError(500, HTTPProxy::kInternalErrorMsg);
- }
- void ExpectClientVersion(const string& version) {
- EXPECT_EQ(version, proxy_.client_version_);
- }
- void ExpectServerHostname(const string& hostname) {
- EXPECT_EQ(hostname, proxy_.server_hostname_);
- }
- void ExpectFirstLine(const string& line) {
- EXPECT_EQ(line, proxy_.client_headers_[0] + "\r\n");
- }
- void ExpectDNSRequest(const string& host, bool return_value) {
- EXPECT_CALL(*dns_client_, Start(StrEq(host), _))
- .WillOnce(Return(return_value));
- }
- void ExpectAsyncConnect(const string& address, int port,
- bool return_value) {
- EXPECT_CALL(*server_async_connection_, Start(IsIPAddress(address), port))
- .WillOnce(Return(return_value));
- }
- void ExpectSyncConnect(const string& address, int port) {
- EXPECT_CALL(*server_async_connection_, Start(IsIPAddress(address), port))
- .WillOnce(DoAll(Invoke(this, &HTTPProxyTest::InvokeSyncConnect),
- Return(true)));
- }
- void ExpectClientData() {
- EXPECT_CALL(dispatcher(),
- CreateReadyHandler(kClientFD,
- IOHandler::kModeOutput,
- CallbackEq(proxy_.write_client_callback_)))
- .WillOnce(ReturnNew<IOHandler>());
- }
- void ExpectClientResult() {
- ExpectClientData();
- ExpectInputTimeout();
- }
- void ExpectServerInput() {
- EXPECT_CALL(dispatcher(),
- CreateInputHandler(kServerFD,
- CallbackEq(proxy_.read_server_callback_), _))
- .WillOnce(ReturnNew<IOHandler>());
- ExpectInputTimeout();
- }
- void ExpectServerOutput() {
- EXPECT_CALL(dispatcher(),
- CreateReadyHandler(kServerFD,
- IOHandler::kModeOutput,
- CallbackEq(proxy_.write_server_callback_)))
- .WillOnce(ReturnNew<IOHandler>());
- ExpectInputTimeout();
- }
- void ExpectRepeatedServerOutput() {
- EXPECT_CALL(dispatcher(),
- CreateReadyHandler(kServerFD, IOHandler::kModeOutput,
- CallbackEq(proxy_.write_server_callback_)))
- .WillOnce(ReturnNew<IOHandler>());
- ExpectRepeatedInputTimeout();
- }
- void ExpectTunnelClose() {
- EXPECT_CALL(sockets(), Close(kClientFD))
- .WillOnce(Return(0));
- EXPECT_CALL(sockets(), Close(kServerFD))
- .WillOnce(Return(0));
- ExpectStop();
- }
- void ExpectRouteRequest() {
- EXPECT_CALL(*connection_.get(), RequestRouting());
- }
- void ExpectRouteRelease() {
- EXPECT_CALL(*connection_.get(), ReleaseRouting());
- }
-
- // Callers for various private routines in the proxy
- bool StartProxy() {
- bool ret = proxy_.Start(&dispatcher_, &sockets_);
- if (ret) {
- dns_client_ = new StrictMock<MockDNSClient>();
- // Passes ownership.
- proxy_.dns_client_.reset(dns_client_);
- server_async_connection_ = new StrictMock<MockAsyncConnection>();
- // Passes ownership.
- proxy_.server_async_connection_.reset(server_async_connection_);
- }
- return ret;
- }
- void AcceptClient(int fd) {
- proxy_.AcceptClient(fd);
- }
- void GetDNSResultFailure(const string& error_msg) {
- Error error(Error::kOperationFailed, error_msg);
- IPAddress address(IPAddress::kFamilyUnknown);
- proxy_.GetDNSResult(error, address);
- }
- void GetDNSResultSuccess(const IPAddress& address) {
- Error error;
- proxy_.GetDNSResult(error, address);
- }
- void OnConnectCompletion(bool result, int sockfd) {
- proxy_.OnConnectCompletion(result, sockfd);
- }
- void ReadFromClient(const string& data) {
- const unsigned char* ptr =
- reinterpret_cast<const unsigned char*>(data.c_str());
- vector<unsigned char> data_bytes(ptr, ptr + data.length());
- InputData proxy_data(data_bytes.data(), data_bytes.size());
- proxy_.ReadFromClient(&proxy_data);
- }
- void ReadFromServer(const string& data) {
- const unsigned char* ptr =
- reinterpret_cast<const unsigned char*>(data.c_str());
- vector<unsigned char> data_bytes(ptr, ptr + data.length());
- InputData proxy_data(data_bytes.data(), data_bytes.size());
- proxy_.ReadFromServer(&proxy_data);
- }
- void SendClientError(int code, const string& error) {
- proxy_.SendClientError(code, error);
- EXPECT_FALSE(proxy_.server_data_.IsEmpty());
- }
- void StopClient() {
- EXPECT_CALL(*dns_client_, Stop());
- EXPECT_CALL(*server_async_connection_, Stop());
- proxy_.StopClient();
- }
- void StopProxy() {
- ExpectStop();
- proxy_.Stop();
- server_async_connection_ = nullptr;
- dns_client_ = nullptr;
- ExpectReset();
- }
- void WriteToClient(int fd) {
- proxy_.WriteToClient(fd);
- }
- void WriteToServer(int fd) {
- proxy_.WriteToServer(fd);
- }
-
- void SetupClient() {
- ExpectStart();
- ASSERT_TRUE(StartProxy());
- ExpectClientInput(kClientFD);
- AcceptClient(kProxyFD);
- EXPECT_EQ(HTTPProxy::kStateReadClientHeader, GetProxyState());
- }
- void SetupConnectWithRequest(const string& url, const string& http_version,
- const string& extra_lines) {
- ExpectDNSRequest("www.chromium.org", true);
- ExpectRouteRequest();
- ReadFromClient(CreateRequest(url, http_version, extra_lines));
- IPAddress addr(IPAddress::kFamilyIPv4);
- EXPECT_TRUE(addr.SetAddressFromString(kServerAddress));
- GetDNSResultSuccess(addr);
- }
- void SetupConnect() {
- SetupConnectWithRequest("/", "1.1", "Host: www.chromium.org:40506");
- }
- void SetupConnectAsync() {
- SetupClient();
- ExpectAsyncConnect(kServerAddress, kServerPort, true);
- ExpectConnectTimeout();
- SetupConnect();
- }
- void SetupConnectComplete() {
- SetupConnectAsync();
- ExpectServerOutput();
- OnConnectCompletion(true, kServerFD);
- EXPECT_EQ(HTTPProxy::kStateTunnelData, GetProxyState());
- }
- void CauseReadError() {
- proxy_.OnReadError(string());
- }
-
- private:
- const string interface_name_;
- // Owned by the HTTPProxy, but tracked here for EXPECT().
- StrictMock<MockAsyncConnection>* server_async_connection_;
- vector<string> dns_servers_;
- // Owned by the HTTPProxy, but tracked here for EXPECT().
- StrictMock<MockDNSClient>* dns_client_;
- MockEventDispatcher dispatcher_;
- MockControl control_;
- std::unique_ptr<MockDeviceInfo> device_info_;
- scoped_refptr<MockConnection> connection_;
- StrictMock<MockSockets> sockets_;
- HTTPProxy proxy_; // Destroy first, before anything it references.
-};
-
-TEST_F(HTTPProxyTest, StartFailSocket) {
- EXPECT_CALL(sockets(), Socket(_, _, _))
- .WillOnce(Return(-1));
- EXPECT_FALSE(StartProxy());
- ExpectReset();
-}
-
-TEST_F(HTTPProxyTest, StartFailBind) {
- EXPECT_CALL(sockets(), Socket(_, _, _))
- .WillOnce(Return(kProxyFD));
- EXPECT_CALL(sockets(), Bind(kProxyFD, _, _))
- .WillOnce(Return(-1));
- EXPECT_CALL(sockets(), Close(kProxyFD))
- .WillOnce(Return(0));
- EXPECT_FALSE(StartProxy());
- ExpectReset();
-}
-
-TEST_F(HTTPProxyTest, StartFailGetSockName) {
- EXPECT_CALL(sockets(), Socket(_, _, _))
- .WillOnce(Return(kProxyFD));
- EXPECT_CALL(sockets(), Bind(kProxyFD, _, _))
- .WillOnce(Return(0));
- EXPECT_CALL(sockets(), GetSockName(kProxyFD, _, _))
- .WillOnce(Return(-1));
- EXPECT_CALL(sockets(), Close(kProxyFD))
- .WillOnce(Return(0));
- EXPECT_FALSE(StartProxy());
- ExpectReset();
-}
-
-TEST_F(HTTPProxyTest, StartFailSetNonBlocking) {
- EXPECT_CALL(sockets(), Socket(_, _, _))
- .WillOnce(Return(kProxyFD));
- EXPECT_CALL(sockets(), Bind(kProxyFD, _, _))
- .WillOnce(Return(0));
- EXPECT_CALL(sockets(), GetSockName(kProxyFD, _, _))
- .WillOnce(Return(0));
- EXPECT_CALL(sockets(), SetNonBlocking(kProxyFD))
- .WillOnce(Return(-1));
- EXPECT_CALL(sockets(), Close(kProxyFD))
- .WillOnce(Return(0));
- EXPECT_FALSE(StartProxy());
- ExpectReset();
-}
-
-TEST_F(HTTPProxyTest, StartFailListen) {
- EXPECT_CALL(sockets(), Socket(_, _, _))
- .WillOnce(Return(kProxyFD));
- EXPECT_CALL(sockets(), Bind(kProxyFD, _, _))
- .WillOnce(Return(0));
- EXPECT_CALL(sockets(), GetSockName(kProxyFD, _, _))
- .WillOnce(Return(0));
- EXPECT_CALL(sockets(), SetNonBlocking(kProxyFD))
- .WillOnce(Return(0));
- EXPECT_CALL(sockets(), Listen(kProxyFD, _))
- .WillOnce(Return(-1));
- EXPECT_CALL(sockets(), Close(kProxyFD))
- .WillOnce(Return(0));
- EXPECT_FALSE(StartProxy());
- ExpectReset();
-}
-
-TEST_F(HTTPProxyTest, StartSuccess) {
- ExpectStart();
- EXPECT_TRUE(StartProxy());
-}
-
-TEST_F(HTTPProxyTest, SendClientError) {
- SetupClient();
- ExpectClientResult();
- SendClientError(500, "This is an error");
- ExpectClientError(500, "This is an error");
-
- // We succeed in sending all but one byte of the client response.
- int buf_len = GetServerData().GetLength();
- EXPECT_CALL(sockets(), Send(kClientFD, _, buf_len, 0))
- .WillOnce(Return(buf_len - 1));
- ExpectInputTimeout();
- WriteToClient(kClientFD);
- EXPECT_EQ(1, GetServerData().GetLength());
- EXPECT_EQ(HTTPProxy::kStateFlushResponse, GetProxyState());
-
- // When we are able to send the last byte, we close the connection.
- EXPECT_CALL(sockets(), Send(kClientFD, _, 1, 0))
- .WillOnce(Return(1));
- EXPECT_CALL(sockets(), Close(kClientFD))
- .WillOnce(Return(0));
- ExpectStop();
- WriteToClient(kClientFD);
- EXPECT_EQ(HTTPProxy::kStateWaitConnection, GetProxyState());
-}
-
-TEST_F(HTTPProxyTest, ReadMissingURL) {
- SetupClient();
- ExpectClientResult();
- ReadFromClient(kBadHeaderMissingURL);
- ExpectClientError(501, "Server could not parse HTTP method");
-}
-
-TEST_F(HTTPProxyTest, ReadMissingVersion) {
- SetupClient();
- ExpectClientResult();
- ReadFromClient(kBadHeaderMissingVersion);
- ExpectClientError(501, "Server only accepts HTTP/1.x requests");
-}
-
-TEST_F(HTTPProxyTest, ReadBadHostname) {
- SetupClient();
- ExpectClientResult();
- ReadFromClient(kBadHostnameLine);
- ExpectClientInternalError();
-}
-
-TEST_F(HTTPProxyTest, GoodFirstLineWithoutURL) {
- SetupClient();
- ExpectClientHeaderTimeout();
- ReadFromClient(kBasicGetHeader);
- ExpectClientVersion("1.1");
- ExpectServerHostname("");
- ExpectFirstLine(kBasicGetHeader);
-}
-
-TEST_F(HTTPProxyTest, GoodFirstLineWithURL) {
- SetupClient();
- ExpectClientHeaderTimeout();
- ReadFromClient(kBasicGetHeaderWithURL);
- ExpectClientVersion("1.1");
- ExpectServerHostname("www.chromium.org");
- ExpectFirstLine(kBasicGetHeader);
-}
-
-TEST_F(HTTPProxyTest, GoodFirstLineWithURLNoSlash) {
- SetupClient();
- ExpectClientHeaderTimeout();
- ReadFromClient(kBasicGetHeaderWithURLNoTrailingSlash);
- ExpectClientVersion("1.1");
- ExpectServerHostname("www.chromium.org");
- ExpectFirstLine(kBasicGetHeader);
-}
-
-TEST_F(HTTPProxyTest, NoHostInRequest) {
- SetupClient();
- ExpectClientResult();
- ReadFromClient(CreateRequest("/", "1.1", ""));
- ExpectClientError(400, "I don't know what host you want me to connect to");
-}
-
-TEST_F(HTTPProxyTest, TooManyColonsInHost) {
- SetupClient();
- ExpectClientResult();
- ReadFromClient(CreateRequest("/", "1.1", "Host: www.chromium.org:80:40506"));
- ExpectClientError(400, "Too many colons in hostname");
-}
-
-TEST_F(HTTPProxyTest, ClientReadError) {
- SetupClient();
- EXPECT_CALL(sockets(), Close(kClientFD))
- .WillOnce(Return(0));
- ExpectStop();
- CauseReadError();
- ExpectClientReset();
-}
-
-TEST_F(HTTPProxyTest, DNSRequestFailure) {
- SetupClient();
- ExpectRouteRequest();
- ExpectDNSRequest("www.chromium.org", false);
- ExpectClientResult();
- ReadFromClient(CreateRequest("/", "1.1", "Host: www.chromium.org:40506"));
- ExpectClientError(502, "Could not resolve hostname");
-}
-
-TEST_F(HTTPProxyTest, DNSRequestDelayedFailure) {
- SetupClient();
- ExpectRouteRequest();
- ExpectDNSRequest("www.chromium.org", true);
- ReadFromClient(CreateRequest("/", "1.1", "Host: www.chromium.org:40506"));
- ExpectClientResult();
- const std::string not_found_error(DNSClient::kErrorNotFound);
- GetDNSResultFailure(not_found_error);
- ExpectClientError(502, string("Could not resolve hostname: ") +
- not_found_error);
-}
-
-TEST_F(HTTPProxyTest, TrailingClientData) {
- SetupClient();
- ExpectRouteRequest();
- ExpectDNSRequest("www.chromium.org", true);
- const string trailing_data("Trailing client data");
- ReadFromClient(CreateRequest("/", "1.1", "Host: www.chromium.org:40506") +
- trailing_data);
- EXPECT_EQ(GetClientData().GetLength() - trailing_data.length(),
- FindInRequest(trailing_data));
- EXPECT_EQ(HTTPProxy::kStateLookupServer, GetProxyState());
-}
-
-TEST_F(HTTPProxyTest, LineContinuation) {
- SetupClient();
- ExpectRouteRequest();
- ExpectDNSRequest("www.chromium.org", true);
- string text_to_keep("X-Long-Header: this is one line\r\n"
- "\tand this is another");
- ReadFromClient(CreateRequest("http://www.chromium.org/", "1.1",
- text_to_keep));
- EXPECT_NE(string::npos, FindInRequest(text_to_keep));
-}
-
-// NB: This tests two different things:
-// 1) That the system replaces the value for "Proxy-Connection" headers.
-// 2) That when it replaces a header, it also removes the text in the line
-// continuation.
-TEST_F(HTTPProxyTest, LineContinuationRemoval) {
- SetupClient();
- ExpectRouteRequest();
- ExpectDNSRequest("www.chromium.org", true);
- string text_to_remove("remove this text please");
- ReadFromClient(CreateRequest("http://www.chromium.org/", "1.1",
- string("Proxy-Connection: stuff\r\n\t") +
- text_to_remove));
- EXPECT_EQ(string::npos, FindInRequest(text_to_remove));
- EXPECT_NE(string::npos, FindInRequest("Proxy-Connection: close\r\n"));
-}
-
-TEST_F(HTTPProxyTest, ConnectSynchronousFailure) {
- SetupClient();
- ExpectAsyncConnect(kServerAddress, kServerPort, false);
- ExpectClientResult();
- SetupConnect();
- ExpectClientError(500, "Could not create socket to connect to server");
-}
-
-TEST_F(HTTPProxyTest, ConnectAsyncConnectFailure) {
- SetupConnectAsync();
- ExpectClientResult();
- OnConnectCompletion(false, -1);
- ExpectClientError(500, "Socket connection delayed failure");
-}
-
-TEST_F(HTTPProxyTest, ConnectSynchronousSuccess) {
- SetupClient();
- ExpectSyncConnect(kServerAddress, 999);
- ExpectRepeatedServerOutput();
- SetupConnectWithRequest("/", "1.1", "Host: www.chromium.org:999");
- EXPECT_EQ(HTTPProxy::kStateTunnelData, GetProxyState());
-}
-
-TEST_F(HTTPProxyTest, ConnectIPAddresss) {
- SetupClient();
- ExpectSyncConnect(kServerAddress, 999);
- ExpectRepeatedServerOutput();
- ExpectRouteRequest();
- ReadFromClient(CreateRequest("/", "1.1",
- StringPrintf("Host: %s:999", kServerAddress)));
- EXPECT_EQ(HTTPProxy::kStateTunnelData, GetProxyState());
-}
-
-TEST_F(HTTPProxyTest, ConnectAsyncConnectSuccess) {
- SetupConnectComplete();
-}
-
-TEST_F(HTTPProxyTest, HTTPConnectMethod) {
- SetupClient();
- ExpectAsyncConnect(kServerAddress, kConnectPort, true);
- ExpectConnectTimeout();
- ExpectRouteRequest();
- ReadFromClient(kConnectQuery);
- ExpectRepeatedInputTimeout();
- ExpectClientData();
- OnConnectCompletion(true, kServerFD);
- ExpectInClientResponse("HTTP/1.1 200 OK\r\n\r\n");
-}
-
-TEST_F(HTTPProxyTest, TunnelData) {
- SetupConnectComplete();
-
- // The proxy is waiting for the server to be ready to accept data.
- EXPECT_CALL(sockets(), Send(kServerFD, _, _, 0))
- .WillOnce(Return(10));
- ExpectServerInput();
- WriteToServer(kServerFD);
- EXPECT_CALL(sockets(), Send(kServerFD, _, _, 0))
- .WillOnce(ReturnArg<2>());
- ExpectInputTimeout();
- WriteToServer(kServerFD);
- EXPECT_EQ(HTTPProxy::kStateTunnelData, GetProxyState());
-
- // Tunnel a reply back to the client.
- const string server_result("200 OK ... and so on");
- ExpectClientResult();
- ReadFromServer(server_result);
- EXPECT_EQ(server_result,
- string(reinterpret_cast<const char*>(
- GetServerData().GetConstData()),
- GetServerData().GetLength()));
-
- // Allow part of the result string to be sent to the client.
- const int part = server_result.length() / 2;
- EXPECT_CALL(sockets(), Send(kClientFD, _, server_result.length(), 0))
- .WillOnce(Return(part));
- ExpectInputTimeout();
- WriteToClient(kClientFD);
- EXPECT_EQ(HTTPProxy::kStateTunnelData, GetProxyState());
-
- // The Server closes the connection while the client is still reading.
- ExpectInputTimeout();
- ReadFromServer("");
- EXPECT_EQ(HTTPProxy::kStateFlushResponse, GetProxyState());
-
- // When the last part of the response is written to the client, we close
- // all connections.
- EXPECT_CALL(sockets(), Send(kClientFD, _, server_result.length() - part, 0))
- .WillOnce(ReturnArg<2>());
- ExpectTunnelClose();
- WriteToClient(kClientFD);
- EXPECT_EQ(HTTPProxy::kStateWaitConnection, GetProxyState());
-}
-
-TEST_F(HTTPProxyTest, TunnelDataFailWriteClient) {
- SetupConnectComplete();
- EXPECT_CALL(sockets(), Send(kClientFD, _, _, 0))
- .WillOnce(Return(-1));
- ExpectTunnelClose();
- WriteToClient(kClientFD);
- ExpectClientReset();
- EXPECT_EQ(HTTPProxy::kStateWaitConnection, GetProxyState());
-}
-
-TEST_F(HTTPProxyTest, TunnelDataFailWriteServer) {
- SetupConnectComplete();
- EXPECT_CALL(sockets(), Send(kServerFD, _, _, 0))
- .WillOnce(Return(-1));
- ExpectTunnelClose();
- WriteToServer(kServerFD);
- ExpectClientReset();
- EXPECT_EQ(HTTPProxy::kStateWaitConnection, GetProxyState());
-}
-
-TEST_F(HTTPProxyTest, TunnelDataFailReadServer) {
- SetupConnectComplete();
- EXPECT_CALL(sockets(), Send(kServerFD, _, _, 0))
- .WillOnce(Return(10));
- ExpectServerInput();
- WriteToServer(kServerFD);
- ExpectTunnelClose();
- CauseReadError();
- ExpectClientReset();
- EXPECT_EQ(HTTPProxy::kStateWaitConnection, GetProxyState());
-}
-
-TEST_F(HTTPProxyTest, TunnelDataFailClientClose) {
- SetupConnectComplete();
- ExpectTunnelClose();
- ReadFromClient("");
- ExpectClientReset();
- EXPECT_EQ(HTTPProxy::kStateWaitConnection, GetProxyState());
-}
-
-TEST_F(HTTPProxyTest, TunnelDataFailServerClose) {
- SetupConnectComplete();
- ExpectTunnelClose();
- ReadFromServer("");
- ExpectClientReset();
- EXPECT_EQ(HTTPProxy::kStateWaitConnection, GetProxyState());
-}
-
-TEST_F(HTTPProxyTest, StopClient) {
- SetupConnectComplete();
- EXPECT_CALL(sockets(), Close(kClientFD))
- .WillOnce(Return(0));
- EXPECT_CALL(sockets(), Close(kServerFD))
- .WillOnce(Return(0));
- ExpectRouteRelease();
- StopClient();
- ExpectClientReset();
- EXPECT_EQ(HTTPProxy::kStateWaitConnection, GetProxyState());
-}
-
-} // namespace shill
diff --git a/scope_logger.cc b/scope_logger.cc
index 815503f..fce1676 100644
--- a/scope_logger.cc
+++ b/scope_logger.cc
@@ -44,7 +44,6 @@
"dns",
"ethernet",
"http",
- "httpproxy",
"inet",
"link",
"manager",
diff --git a/scope_logger.h b/scope_logger.h
index 3d5a817..c1ee00e 100644
--- a/scope_logger.h
+++ b/scope_logger.h
@@ -49,7 +49,6 @@
kDNS,
kEthernet,
kHTTP,
- kHTTPProxy,
kInet,
kLink,
kManager,
diff --git a/scope_logger_unittest.cc b/scope_logger_unittest.cc
index 8b37feb..ba55b62 100644
--- a/scope_logger_unittest.cc
+++ b/scope_logger_unittest.cc
@@ -61,7 +61,6 @@
"dns+"
"ethernet+"
"http+"
- "httpproxy+"
"inet+"
"link+"
"manager+"
diff --git a/service.cc b/service.cc
index d6b2fb2..20779d3 100644
--- a/service.cc
+++ b/service.cc
@@ -37,7 +37,6 @@
#include "shill/control_interface.h"
#include "shill/dhcp_properties.h"
#include "shill/error.h"
-#include "shill/http_proxy.h"
#include "shill/logging.h"
#include "shill/manager.h"
#include "shill/metrics.h"
@@ -229,8 +228,6 @@
// see an autotest depending on it.
store_.RegisterConstString(kErrorProperty, &error_);
store_.RegisterConstString(kErrorDetailsProperty, &error_details_);
- HelpRegisterConstDerivedUint16(kHTTPProxyPortProperty,
- &Service::GetHTTPProxyPort);
HelpRegisterConstDerivedRpcIdentifier(kIPConfigProperty,
&Service::GetIPConfigRpcIdentifier);
HelpRegisterDerivedBool(kIsActiveProperty, &Service::IsActive, nullptr,
@@ -808,14 +805,9 @@
void Service::SetConnection(const ConnectionRefPtr& connection) {
if (connection.get()) {
- // TODO(pstew): Make this function testable by using a factory here.
- // http://crbug.com/216664
- http_proxy_.reset(new HTTPProxy(connection));
- http_proxy_->Start(dispatcher_, sockets_.get());
Error unused_error;
connection->set_tethering(GetTethering(&unused_error));
} else {
- http_proxy_.reset();
static_ip_parameters_.ClearSavedParameters();
}
connection_ = connection;
@@ -1629,13 +1621,6 @@
return (profile_ != old_profile);
}
-uint16_t Service::GetHTTPProxyPort(Error* /*error*/) const {
- if (http_proxy_.get()) {
- return static_cast<uint16_t>(http_proxy_->proxy_port());
- }
- return 0;
-}
-
string Service::GetProxyConfig(Error* error) {
return proxy_config_;
}
diff --git a/service.h b/service.h
index aea2ddd..d81b532 100644
--- a/service.h
+++ b/service.h
@@ -53,7 +53,6 @@
class Endpoint;
class Error;
class EventDispatcher;
-class HTTPProxy;
class KeyValueStore;
class Manager;
class Metrics;
@@ -802,9 +801,6 @@
std::string GetProfileRpcId(Error* error);
bool SetProfileRpcId(const std::string& profile, Error* error);
- // Returns TCP port of service's HTTP proxy in host order.
- uint16_t GetHTTPProxyPort(Error* error) const;
-
std::string GetProxyConfig(Error* error);
bool SetProxyConfig(const std::string& proxy_config, Error* error);
@@ -910,7 +906,6 @@
std::unique_ptr<ServiceAdaptorInterface> adaptor_;
std::unique_ptr<ServicePropertyChangeNotifier> property_change_notifier_;
- std::unique_ptr<HTTPProxy> http_proxy_;
ConnectionRefPtr connection_;
StaticIPParameters static_ip_parameters_;
Metrics* metrics_;
diff --git a/shill.gyp b/shill.gyp
index 947f444..9159915 100644
--- a/shill.gyp
+++ b/shill.gyp
@@ -491,7 +491,6 @@
'file_reader.cc',
'geolocation_info.cc',
'hook_table.cc',
- 'http_proxy.cc',
'http_request.cc',
'http_url.cc',
'icmp.cc',
@@ -710,7 +709,6 @@
'fake_store.cc',
'file_reader_unittest.cc',
'hook_table_unittest.cc',
- 'http_proxy_unittest.cc',
'http_request_unittest.cc',
'http_url_unittest.cc',
'icmp_unittest.cc',
diff --git a/vpn/vpn_service_unittest.cc b/vpn/vpn_service_unittest.cc
index b52331a..6fce988 100644
--- a/vpn/vpn_service_unittest.cc
+++ b/vpn/vpn_service_unittest.cc
@@ -252,7 +252,6 @@
TEST_F(VPNServiceTest, SetConnection) {
EXPECT_FALSE(service_->connection_binder_.get());
EXPECT_FALSE(service_->connection());
- EXPECT_CALL(*sockets_, Socket(_, _, _)).WillOnce(Return(-1));
service_->SetConnection(connection_);
ASSERT_TRUE(service_->connection_binder_.get());
EXPECT_EQ(connection_.get(),
@@ -262,7 +261,6 @@
}
TEST_F(VPNServiceTest, OnConnectionDisconnected) {
- EXPECT_CALL(*sockets_, Socket(_, _, _)).WillOnce(Return(-1));
service_->SetConnection(connection_);
EXPECT_CALL(*driver_, OnConnectionDisconnected()).Times(1);
connection_->OnLowerDisconnect();
@@ -361,7 +359,6 @@
TEST_F(VPNServiceTest, GetPhysicalTechnologyPropertyFailsIfNoCarrier) {
scoped_refptr<Connection> null_connection;
- EXPECT_CALL(*sockets_, Socket(_, _, _)).WillOnce(Return(-1));
service_->SetConnection(connection_);
EXPECT_EQ(connection_.get(), service_->connection().get());
@@ -383,7 +380,6 @@
EXPECT_CALL(*connection_, GetCarrierConnection())
.WillOnce(Return(lower_connection_));
- EXPECT_CALL(*sockets_, Socket(_, _, _)).WillOnce(Return(-1));
service_->SetConnection(connection_);
EXPECT_EQ(connection_.get(), service_->connection().get());
@@ -407,7 +403,6 @@
TEST_F(VPNServiceTest, GetTethering) {
scoped_refptr<Connection> null_connection;
- EXPECT_CALL(*sockets_, Socket(_, _, _)).WillOnce(Return(-1));
service_->SetConnection(connection_);
EXPECT_EQ(connection_.get(), service_->connection().get());
