| /* |
| * 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 "webrtc/base/autodetectproxy.h" |
| #include "webrtc/base/httpcommon.h" |
| #include "webrtc/base/httpcommon-inl.h" |
| #include "webrtc/base/nethelpers.h" |
| |
| namespace rtc { |
| |
| static const ProxyType TEST_ORDER[] = { |
| PROXY_HTTPS, PROXY_SOCKS5, PROXY_UNKNOWN |
| }; |
| |
| static const int kSavedStringLimit = 128; |
| |
| static void SaveStringToStack(char *dst, |
| const std::string &src, |
| size_t dst_size) { |
| strncpy(dst, src.c_str(), dst_size - 1); |
| dst[dst_size - 1] = '\0'; |
| } |
| |
| AutoDetectProxy::AutoDetectProxy(const std::string& user_agent) |
| : agent_(user_agent), resolver_(NULL), socket_(NULL), next_(0) { |
| } |
| |
| bool AutoDetectProxy::GetProxyForUrl(const char* agent, |
| const char* url, |
| rtc::ProxyInfo* proxy) { |
| return GetProxySettingsForUrl(agent, url, proxy, true); |
| } |
| |
| AutoDetectProxy::~AutoDetectProxy() { |
| if (resolver_) { |
| resolver_->Destroy(false); |
| } |
| } |
| |
| void AutoDetectProxy::DoWork() { |
| // TODO: Try connecting to server_url without proxy first here? |
| if (!server_url_.empty()) { |
| LOG(LS_INFO) << "GetProxySettingsForUrl(" << server_url_ << ") - start"; |
| GetProxyForUrl(agent_.c_str(), server_url_.c_str(), &proxy_); |
| LOG(LS_INFO) << "GetProxySettingsForUrl - stop"; |
| } |
| Url<char> url(proxy_.address.HostAsURIString()); |
| if (url.valid()) { |
| LOG(LS_WARNING) << "AutoDetectProxy removing http prefix on proxy host"; |
| proxy_.address.SetIP(url.host()); |
| } |
| LOG(LS_INFO) << "AutoDetectProxy found proxy at " << proxy_.address; |
| if (proxy_.type == PROXY_UNKNOWN) { |
| LOG(LS_INFO) << "AutoDetectProxy initiating proxy classification"; |
| Next(); |
| // Process I/O until Stop() |
| Thread::Current()->ProcessMessages(Thread::kForever); |
| // Clean up the autodetect socket, from the thread that created it |
| delete socket_; |
| } |
| // TODO: If we found a proxy, try to use it to verify that it |
| // works by sending a request to server_url. This could either be |
| // done here or by the HttpPortAllocator. |
| } |
| |
| void AutoDetectProxy::OnMessage(Message *msg) { |
| if (MSG_UNRESOLVABLE == msg->message_id) { |
| // If we can't resolve the proxy, skip straight to failure. |
| Complete(PROXY_UNKNOWN); |
| } else if (MSG_TIMEOUT == msg->message_id) { |
| OnTimeout(); |
| } else { |
| // This must be the ST_MSG_WORKER_DONE message that deletes the |
| // AutoDetectProxy object. We have observed crashes within this stack that |
| // seem to be highly reproducible for a small subset of users and thus are |
| // probably correlated with a specific proxy setting, so copy potentially |
| // relevant information onto the stack to make it available in Windows |
| // minidumps. |
| |
| // Save the user agent and the number of auto-detection passes that we |
| // needed. |
| char agent[kSavedStringLimit]; |
| SaveStringToStack(agent, agent_, sizeof agent); |
| |
| int next = next_; |
| |
| // Now the detected proxy config (minus the password field, which could be |
| // sensitive). |
| ProxyType type = proxy().type; |
| |
| char address_hostname[kSavedStringLimit]; |
| SaveStringToStack(address_hostname, |
| proxy().address.hostname(), |
| sizeof address_hostname); |
| |
| IPAddress address_ip = proxy().address.ipaddr(); |
| |
| uint16_t address_port = proxy().address.port(); |
| |
| char autoconfig_url[kSavedStringLimit]; |
| SaveStringToStack(autoconfig_url, |
| proxy().autoconfig_url, |
| sizeof autoconfig_url); |
| |
| bool autodetect = proxy().autodetect; |
| |
| char bypass_list[kSavedStringLimit]; |
| SaveStringToStack(bypass_list, proxy().bypass_list, sizeof bypass_list); |
| |
| char username[kSavedStringLimit]; |
| SaveStringToStack(username, proxy().username, sizeof username); |
| |
| SignalThread::OnMessage(msg); |
| |
| // Log the gathered data at a log level that will never actually be enabled |
| // so that the compiler is forced to retain the data on the stack. |
| LOG(LS_SENSITIVE) << agent << " " << next << " " << type << " " |
| << address_hostname << " " << address_ip << " " |
| << address_port << " " << autoconfig_url << " " |
| << autodetect << " " << bypass_list << " " << username; |
| } |
| } |
| |
| void AutoDetectProxy::OnResolveResult(AsyncResolverInterface* resolver) { |
| if (resolver != resolver_) { |
| return; |
| } |
| int error = resolver_->GetError(); |
| if (error == 0) { |
| LOG(LS_VERBOSE) << "Resolved " << proxy_.address << " to " |
| << resolver_->address(); |
| proxy_.address = resolver_->address(); |
| if (!DoConnect()) { |
| Thread::Current()->Post(RTC_FROM_HERE, this, MSG_TIMEOUT); |
| } |
| } else { |
| LOG(LS_INFO) << "Failed to resolve " << resolver_->address(); |
| resolver_->Destroy(false); |
| resolver_ = NULL; |
| proxy_.address = SocketAddress(); |
| Thread::Current()->Post(RTC_FROM_HERE, this, MSG_UNRESOLVABLE); |
| } |
| } |
| |
| void AutoDetectProxy::Next() { |
| if (TEST_ORDER[next_] >= PROXY_UNKNOWN) { |
| Complete(PROXY_UNKNOWN); |
| return; |
| } |
| |
| LOG(LS_VERBOSE) << "AutoDetectProxy connecting to " |
| << proxy_.address.ToSensitiveString(); |
| |
| if (socket_) { |
| Thread::Current()->Clear(this, MSG_TIMEOUT); |
| Thread::Current()->Clear(this, MSG_UNRESOLVABLE); |
| socket_->Close(); |
| Thread::Current()->Dispose(socket_); |
| socket_ = NULL; |
| } |
| int timeout = 2000; |
| if (proxy_.address.IsUnresolvedIP()) { |
| // Launch an asyncresolver. This thread will spin waiting for it. |
| timeout += 2000; |
| if (!resolver_) { |
| resolver_ = new AsyncResolver(); |
| } |
| resolver_->SignalDone.connect(this, &AutoDetectProxy::OnResolveResult); |
| resolver_->Start(proxy_.address); |
| } else { |
| if (!DoConnect()) { |
| Thread::Current()->Post(RTC_FROM_HERE, this, MSG_TIMEOUT); |
| return; |
| } |
| } |
| Thread::Current()->PostDelayed(RTC_FROM_HERE, timeout, this, MSG_TIMEOUT); |
| } |
| |
| bool AutoDetectProxy::DoConnect() { |
| if (resolver_) { |
| resolver_->Destroy(false); |
| resolver_ = NULL; |
| } |
| socket_ = |
| Thread::Current()->socketserver()->CreateAsyncSocket( |
| proxy_.address.family(), SOCK_STREAM); |
| if (!socket_) { |
| LOG(LS_VERBOSE) << "Unable to create socket for " << proxy_.address; |
| return false; |
| } |
| socket_->SignalConnectEvent.connect(this, &AutoDetectProxy::OnConnectEvent); |
| socket_->SignalReadEvent.connect(this, &AutoDetectProxy::OnReadEvent); |
| socket_->SignalCloseEvent.connect(this, &AutoDetectProxy::OnCloseEvent); |
| socket_->Connect(proxy_.address); |
| return true; |
| } |
| |
| void AutoDetectProxy::Complete(ProxyType type) { |
| Thread::Current()->Clear(this, MSG_TIMEOUT); |
| Thread::Current()->Clear(this, MSG_UNRESOLVABLE); |
| if (socket_) { |
| socket_->Close(); |
| } |
| |
| proxy_.type = type; |
| LoggingSeverity sev = (proxy_.type == PROXY_UNKNOWN) ? LS_ERROR : LS_INFO; |
| LOG_V(sev) << "AutoDetectProxy detected " |
| << proxy_.address.ToSensitiveString() |
| << " as type " << proxy_.type; |
| |
| Thread::Current()->Quit(); |
| } |
| |
| void AutoDetectProxy::OnConnectEvent(AsyncSocket * socket) { |
| std::string probe; |
| |
| switch (TEST_ORDER[next_]) { |
| case PROXY_HTTPS: |
| probe.assign("CONNECT www.google.com:443 HTTP/1.0\r\n" |
| "User-Agent: "); |
| probe.append(agent_); |
| probe.append("\r\n" |
| "Host: www.google.com\r\n" |
| "Content-Length: 0\r\n" |
| "Proxy-Connection: Keep-Alive\r\n" |
| "\r\n"); |
| break; |
| case PROXY_SOCKS5: |
| probe.assign("\005\001\000", 3); |
| break; |
| default: |
| ASSERT(false); |
| return; |
| } |
| |
| LOG(LS_VERBOSE) << "AutoDetectProxy probing type " << TEST_ORDER[next_] |
| << " sending " << probe.size() << " bytes"; |
| socket_->Send(probe.data(), probe.size()); |
| } |
| |
| void AutoDetectProxy::OnReadEvent(AsyncSocket * socket) { |
| char data[257]; |
| int len = socket_->Recv(data, 256, nullptr); |
| if (len > 0) { |
| data[len] = 0; |
| LOG(LS_VERBOSE) << "AutoDetectProxy read " << len << " bytes"; |
| } |
| |
| switch (TEST_ORDER[next_]) { |
| case PROXY_HTTPS: |
| if ((len >= 2) && (data[0] == '\x05')) { |
| Complete(PROXY_SOCKS5); |
| return; |
| } |
| if ((len >= 5) && (strncmp(data, "HTTP/", 5) == 0)) { |
| Complete(PROXY_HTTPS); |
| return; |
| } |
| break; |
| case PROXY_SOCKS5: |
| if ((len >= 2) && (data[0] == '\x05')) { |
| Complete(PROXY_SOCKS5); |
| return; |
| } |
| break; |
| default: |
| ASSERT(false); |
| return; |
| } |
| |
| ++next_; |
| Next(); |
| } |
| |
| void AutoDetectProxy::OnTimeout() { |
| LOG(LS_VERBOSE) << "Timed out waiting for AsyncResolver."; |
| // If a resolver timed out we shouldn't try to use it again since it may be |
| // in the middle of resolving the last address. |
| if (resolver_) { |
| resolver_->SignalDone.disconnect(this); |
| resolver_->Destroy(false); |
| resolver_ = nullptr; |
| } |
| ++next_; |
| Next(); |
| } |
| |
| void AutoDetectProxy::OnCloseEvent(AsyncSocket * socket, int error) { |
| LOG(LS_VERBOSE) << "AutoDetectProxy closed with error: " << error; |
| ++next_; |
| Next(); |
| } |
| |
| } // namespace rtc |