Bypass data reduction proxy when using VPN

components/data_reduction_proxy/browser/data_reduction_proxy_settings.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/data_reduction_proxy/browser/data_reduction_proxy_settings.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_member.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/data_reduction_proxy/browser/data_reduction_proxy_auth_request_handler.h"
 #include "components/data_reduction_proxy/browser/data_reduction_proxy_configurator.h"
 #include "components/data_reduction_proxy/browser/data_reduction_proxy_params.h"
 #include "components/data_reduction_proxy/browser/data_reduction_proxy_usage_stats.h"
 #include "components/data_reduction_proxy/common/data_reduction_proxy_pref_names.h"
 #include "components/data_reduction_proxy/common/data_reduction_proxy_switches.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
+#include "net/base/net_util.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 #include "url/gurl.h"
 
 
 using base::StringPrintf;
 
 namespace {
+// Values of the UMA DataReductionProxy.NetworkChangeEvents histograms.
+// This enum must remain synchronized with the enum of the same
+// name in metrics/histograms/histograms.xml.
+enum DataReductionProxyNetworkChangeEvent {
+  IP_CHANGED = 0, // The client IP address changed.
+  DISABLED_ON_VPN = 1, // The proxy is disabled because a VPN is running.
+  CHANGE_EVENT_COUNT = 2 // This must always be last.
+};
 
 // Key of the UMA DataReductionProxy.StartupState histogram.
 const char kUMAProxyStartupStateHistogram[] =
     "DataReductionProxy.StartupState";
 
 // Key of the UMA DataReductionProxy.ProbeURL histogram.
 const char kUMAProxyProbeURL[] = "DataReductionProxy.ProbeURL";
 
+// Record a network change event.
+void RecordNetworkChangeEvent(DataReductionProxyNetworkChangeEvent event) {
+  UMA_HISTOGRAM_ENUMERATION("DataReductionProxy.NetworkChangeEvents",
+                            event,
+                            CHANGE_EVENT_COUNT);
+}
+
 int64 GetInt64PrefValue(const base::ListValue& list_value, size_t index) {
   int64 val = 0;
   std::string pref_value;
   bool rv = list_value.GetString(index, &pref_value);
   DCHECK(rv);
   if (rv) {
     rv = base::StringToInt64(pref_value, &val);
     DCHECK(rv);
   }
   return val;
 }
 
 bool IsEnabledOnCommandLine() {
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   return command_line.HasSwitch(
       data_reduction_proxy::switches::kEnableDataReductionProxy);
 }
 
 }  // namespace
 
 namespace data_reduction_proxy {
 
 DataReductionProxySettings::DataReductionProxySettings(
     DataReductionProxyParams* params)
     : restricted_by_carrier_(false),
       enabled_by_user_(false),
+      disabled_on_vpn_(false),
       prefs_(NULL),
       local_state_prefs_(NULL),
-      url_request_context_getter_(NULL),
-      usage_stats_(NULL) {
+      url_request_context_getter_(NULL) {
   DCHECK(params);
   params_.reset(params);
 }
 
 DataReductionProxySettings::~DataReductionProxySettings() {
   if (params_->allowed())
     spdy_proxy_auth_enabled_.Destroy();
 }
 
 void DataReductionProxySettings::InitPrefMembers() {
@@ skipping 218 matching lines @@
       kOn + std::string(" ") + (restricted ? kRestricted : kUnrestricted);
 
   LOG(WARNING) << "SPDY proxy " << (enabled ? annotated_on : kOff)
                << " " << (at_startup ? kAtStartup : kByUser);
 }
 
 void DataReductionProxySettings::OnIPAddressChanged() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (enabled_by_user_) {
     DCHECK(params_->allowed());
+    RecordNetworkChangeEvent(IP_CHANGED);
+    if (DisableIfVPN())
+      return;
     ProbeWhetherDataReductionProxyIsAvailable();
     WarmProxyConnection();
   }
 }
 
 void DataReductionProxySettings::OnProxyEnabledPrefChange() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!params_->allowed())
     return;
   MaybeActivateDataReductionProxy(false);
@@ skipping 28 matching lines @@
   // TODO(marq): Consider moving this so stats are wiped the first time the
   // proxy settings are actually (not maybe) turned on.
   if (spdy_proxy_auth_enabled_.GetValue() &&
       !prefs->GetBoolean(prefs::kDataReductionProxyWasEnabledBefore)) {
     prefs->SetBoolean(prefs::kDataReductionProxyWasEnabledBefore, true);
     ResetDataReductionStatistics();
   }
 
   // Configure use of the data reduction proxy if it is enabled.
   enabled_by_user_= IsDataReductionProxyEnabled();
-  SetProxyConfigs(enabled_by_user_,
+  SetProxyConfigs(enabled_by_user_ && !disabled_on_vpn_,
                   IsDataReductionProxyAlternativeEnabled(),
                   restricted_by_carrier_,
                   at_startup);
 
   // Check if the proxy has been restricted explicitly by the carrier.
-  if (enabled_by_user_) {
+  if (enabled_by_user_ && !disabled_on_vpn_) {
     ProbeWhetherDataReductionProxyIsAvailable();
     WarmProxyConnection();
   }
 }
 
 void DataReductionProxySettings::SetProxyConfigs(bool enabled,
                                                  bool alternative_enabled,
                                                  bool restricted,
                                                  bool at_startup) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 39 matching lines @@
                             result,
                             PROBE_URL_FETCH_RESULT_COUNT);
 }
 
 void DataReductionProxySettings::RecordStartupState(ProxyStartupState state) {
   UMA_HISTOGRAM_ENUMERATION(kUMAProxyStartupStateHistogram,
                             state,
                             PROXY_STARTUP_STATE_COUNT);
 }
 
+void DataReductionProxySettings::GetNetworkList(
+    net::NetworkInterfaceList* interfaces,
+    int policy) {
+  net::GetNetworkList(interfaces, policy);
+}
+
 void DataReductionProxySettings::ResetParamsForTest(
     DataReductionProxyParams* params) {
   params_.reset(params);
 }
 
 DataReductionProxySettings::ContentLengthList
 DataReductionProxySettings::GetDailyContentLengths(const char* pref_name) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DataReductionProxySettings::ContentLengthList content_lengths;
   const base::ListValue* list_value = GetLocalStatePrefs()->GetList(pref_name);
@@ skipping 40 matching lines @@
        i < kNumDaysInHistory; ++i) {
     orig += GetInt64PrefValue(*original_list, i);
     recv += GetInt64PrefValue(*received_list, i);
   }
   *original_content_length = orig;
   *received_content_length = recv;
   *last_update_time =
       local_state->GetInt64(prefs::kDailyHttpContentLengthLastUpdateDate);
 }
 
-// static
-base::string16 DataReductionProxySettings::AuthHashForSalt(
-    int64 salt,
-    const std::string& key) {
-  std::string salted_key =
-      base::StringPrintf("%lld%s%lld",
-                         static_cast<long long>(salt),
-                         key.c_str(),
-                         static_cast<long long>(salt));
-  return base::UTF8ToUTF16(base::MD5String(salted_key));
-}
-
 net::URLFetcher* DataReductionProxySettings::GetBaseURLFetcher(
     const GURL& gurl,
     int load_flags) {
 
   net::URLFetcher* fetcher = net::URLFetcher::Create(gurl,
                                                      net::URLFetcher::GET,
                                                      this);
   fetcher->SetLoadFlags(load_flags);
   DCHECK(url_request_context_getter_);
   fetcher->SetRequestContext(url_request_context_getter_);
@@ skipping 25 matching lines @@
 }
 
 void DataReductionProxySettings::WarmProxyConnection() {
   net::URLFetcher* fetcher = GetURLFetcherForWarmup();
   if (!fetcher)
     return;
   warmup_fetcher_.reset(fetcher);
   warmup_fetcher_->Start();
 }
 
+bool DataReductionProxySettings::DisableIfVPN() {
+  net::NetworkInterfaceList network_interfaces;
+  GetNetworkList(&network_interfaces, 0);
+  // VPNs use a "tun" interface, so the presence of a "tun" interface indicates
+  // a VPN is in use.
+  // TODO(kundaji): Verify this works on Windows.
+  const std::string vpn_interface_name_prefix = "tun";
+  for (size_t i = 0; i < network_interfaces.size(); ++i) {
+    std::string interface_name = network_interfaces[i].name;
+    if (LowerCaseEqualsASCII(
+        interface_name.begin(),
+        interface_name.begin() + vpn_interface_name_prefix.size(),
+        vpn_interface_name_prefix.c_str())) {
+      SetProxyConfigs(false,
+                      IsDataReductionProxyAlternativeEnabled(),
+                      false,
+                      false);
+      disabled_on_vpn_ = true;
+      RecordNetworkChangeEvent(DISABLED_ON_VPN);
+      return true;
+    }
+  }
+  if (disabled_on_vpn_) {
+    SetProxyConfigs(enabled_by_user_,
+                    IsDataReductionProxyAlternativeEnabled(),
+                    restricted_by_carrier_,
+                    false);
+  }
+  disabled_on_vpn_ = false;
+  return false;
+}
+
 }  // namespace data_reduction_proxy