[net] Add an informational bubble to about:net-internals#proxy when using a single SOCKS v5 proxy s…

chrome/browser/resources/net_internals/proxy_view.js

 // Copyright (c) 2012 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.
 
 /**
  * This view displays information on the proxy setup:
  *
  *   - Shows the current proxy settings.
  *   - Has a button to reload these settings.
  *   - Shows the list of proxy hostnames that are cached as "bad".
@@ skipping 28 matching lines @@
   // ID for special HTML element in category_tabs.html
   ProxyView.TAB_HANDLE_ID = 'tab-handle-proxy';
 
   // IDs for special HTML elements in proxy_view.html
   ProxyView.MAIN_BOX_ID = 'proxy-view-tab-content';
   ProxyView.ORIGINAL_SETTINGS_DIV_ID = 'proxy-view-original-settings';
   ProxyView.EFFECTIVE_SETTINGS_DIV_ID = 'proxy-view-effective-settings';
   ProxyView.RELOAD_SETTINGS_BUTTON_ID = 'proxy-view-reload-settings';
   ProxyView.BAD_PROXIES_TBODY_ID = 'proxy-view-bad-proxies-tbody';
   ProxyView.CLEAR_BAD_PROXIES_BUTTON_ID = 'proxy-view-clear-bad-proxies';
+  ProxyView.SOCKS_HINTS_DIV_ID = 'proxy-view-socks-hints';
+  ProxyView.SOCKS_HINTS_FLAG_DIV_ID = 'proxy-view-socks-hints-flag';
 
   cr.addSingletonGetter(ProxyView);
 
   ProxyView.prototype = {
     // Inherit the superclass's methods.
     __proto__: superClass.prototype,
 
     onLoadLogFinish: function(data) {
       return this.onProxySettingsChanged(data.proxySettings) &&
              this.onBadProxiesChanged(data.badProxies);
     },
 
     onProxySettingsChanged: function(proxySettings) {
       // Both |original| and |effective| are dictionaries describing the
       // settings.
       $(ProxyView.ORIGINAL_SETTINGS_DIV_ID).innerHTML = '';
       $(ProxyView.EFFECTIVE_SETTINGS_DIV_ID).innerHTML = '';
 
       if (!proxySettings)

[mmenke, 2013/03/07 20:16:57]

Should we be hiding the hints here?

[eroman, 2013/03/07 20:23:32]

Good point. Yes we should.

         return false;
 
       var original = proxySettings.original;
       var effective = proxySettings.effective;
 
       $(ProxyView.ORIGINAL_SETTINGS_DIV_ID).innerText =
           proxySettingsToString(original);
       $(ProxyView.EFFECTIVE_SETTINGS_DIV_ID).innerText =
           proxySettingsToString(effective);
+
+      this.updateSocksHints_(effective);
+
       return true;
     },
 
     onBadProxiesChanged: function(badProxies) {
       $(ProxyView.BAD_PROXIES_TBODY_ID).innerHTML = '';
 
       if (!badProxies)
         return false;
 
       // Add a table row for each bad proxy entry.
       for (var i = 0; i < badProxies.length; ++i) {
         var entry = badProxies[i];
         var badUntilDate = timeutil.convertTimeTicksToDate(entry.bad_until);
 
         var tr = addNode($(ProxyView.BAD_PROXIES_TBODY_ID), 'tr');
 
         var nameCell = addNode(tr, 'td');
         var badUntilCell = addNode(tr, 'td');
 
         addTextNode(nameCell, entry.proxy_uri);
         timeutil.addNodeWithDate(badUntilCell, badUntilDate);
       }
       return true;
+    },
+
+    updateSocksHints_: function(proxySettings) {
+      setNodeDisplay($(ProxyView.SOCKS_HINTS_DIV_ID), false);
+
+      var socksProxy = getSocks5Proxy_(proxySettings.single_proxy);
+      if (!socksProxy)
+        return;
+
+      // Suggest a recommended --host-resolver-rules.
+      // NOTE: This does not compensate for any proxy bypass rules. If the
+      // proxy settings include proxy bypasses the user may need to expand the
+      // exclusions for host resolving.

[mmenke, 2013/03/07 20:16:57]

If this isn't a TODO, should this be in the displayed comment?

[eroman, 2013/03/07 20:23:32]

I considered just implementing this, however the supported formats for
--host-resolver-rules and proxy bypass rules are not 1:1. Proxy bypass rules
allow for things like IP block ranges "ffe1::3/17", and "<local>". I could
expand on the C++ side, but not sure that is worth the effort.

Another difference is host-resolver-rules just does string matching, so it won't
compensate for IP literal normalization (you could specify an IPv6 address that
will never be matched, if it is not given in normalized form).

Since this is just a mini-hack, which will hopefully be superceded in the future
when there is better understanding, or better support for setting proxies in
Chrome.

Hence I don't think that complexity is something worth implementing in the
Javascript, that is why no TODO.

[mmenke, 2013/03/07 20:26:06]

That sounds reasonable.  But I was actually thinking if it's not a TODO, it
should perhaps be mentioned in the text we display to the user.  Just something
along the lines that anything set to bypass the proxy will require additional
rules.

+      var hostResolverRules = 'MAP * ~NOTFOUND , EXCLUDE ' + socksProxy.host;
+      var hostResolverRulesFlag = '--host-resolver-rules="' +
+                                  hostResolverRules + '"';
+
+      // TODO(eroman): On Linux the ClientInfo.command_line is wrong in that it
+      // doesn't include any quotes around the parameters. This means the
+      // string search above is going to fail :(
+      if (ClientInfo.command_line &&
+          ClientInfo.command_line.indexOf(hostResolverRulesFlag) != -1) {
+        // Chrome is already using the suggested resolver rules.
+        return;
+      }
+
+      $(ProxyView.SOCKS_HINTS_FLAG_DIV_ID).innerText = hostResolverRulesFlag;
+      setNodeDisplay($(ProxyView.SOCKS_HINTS_DIV_ID), true);
     }
   };
 
+  function getSocks5Proxy_(proxyString) {
+    var pattern = /^socks5:\/\/(.*)$/;
+    var matches = pattern.exec(proxyString);
+
+    if (!matches)
+      return undefined;

[mmenke, 2013/03/07 20:16:57]

I think returning null is a bit more natural.

[eroman, 2013/03/07 20:23:32]

Will do.

+
+    var hostPortString = matches[1];
+
+    matches = /^(.*):(\d+)$/.exec(hostPortString);
+    if (!matches)
+      return undefined;
+
+    var result = {host: matches[1], port: matches[2]};
+
+    // Strip brackets off of IPv6 literals.
+    matches = /^\[(.*)\]$/.exec(result.host);
+    if (matches)
+      result.host = matches[1];
+
+    return result;
+  }
+
   return ProxyView;
 })();