Add three of the six extensions to PAC that Internet Explorer supports. ...

net/proxy/proxy_resolver_js_bindings.cc

 // Copyright (c) 2009 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 "build/build_config.h"
+
+#if defined(OS_WIN)
+#include <ws2tcpip.h>
+#else
+#include <netdb.h>
+#endif
+
 #include "net/proxy/proxy_resolver_js_bindings.h"
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/waitable_event.h"
 #include "net/base/address_list.h"
 #include "net/base/host_resolver.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
@@ skipping 75 matching lines @@
                     MessageLoop* host_resolver_loop)
       : host_resolver_(new SyncHostResolverBridge(
           host_resolver, host_resolver_loop)) {}
 
   // Handler for "alert(message)".
   virtual void Alert(const std::string& message) {
     LOG(INFO) << "PAC-alert: " << message;
   }
 
   // Handler for "myIpAddress()". Returns empty string on failure.
+  // TODO(eroman): Perhaps enumerate the interfaces directly, using
+  // getifaddrs().
   virtual std::string MyIpAddress() {
     // DnsResolve("") returns "", so no need to check for failure.
     return DnsResolve(GetHostName());
   }
 
+  // Handler for "myIpAddressEx()". Returns empty string on failure.
+  virtual std::string MyIpAddressEx() {
+    return DnsResolveEx(GetHostName());
+  }
+
   // Handler for "dnsResolve(host)". Returns empty string on failure.
   virtual std::string DnsResolve(const std::string& host) {
-    // TODO(eroman): Should this return our IP address, or fail, or
-    // simply be unspecified (works differently on windows and mac os x).
-    if (host.empty())
-      return std::string();
-
     // Do a sync resolve of the hostname.
     // Disable IPv6 results. We do this because Internet Explorer does it --

[wtc, 2009/10/24 04:40:59]

I studied the original specification of the PAC script helper functions today.
Although not explicitly stated, it's clear that those functions should only
return IPv4 addresses.  The evidence is the mention of "dotted decimal"
notation and "0" and "255" as masks for addresses.

So we now have a stronger reason to get only IPv4 results than "because
Internet Explorer does it".

     // consequently a lot of existing PAC scripts assume they will only get
     // IPv4 results, and will misbehave if they get an IPv6 result.
     // See http://crbug.com/24641 for more details.
     net::AddressList address_list;
     int result = host_resolver_->Resolve(host,
                                          ADDRESS_FAMILY_IPV4,
                                          &address_list);
 
     if (result != OK)
       return std::string();  // Failed.
 
     if (!address_list.head())
       return std::string();
 
     // There may be multiple results; we will just use the first one.
     // This returns empty string on failure.
     return net::NetAddressToString(address_list.head());
   }
 
+  // Handler for "dnsResolveEx(host)". Returns empty string on failure.
+  virtual std::string DnsResolveEx(const std::string& host) {
+    // Do a sync resolve of the hostname.
+    net::AddressList address_list;
+    int result = host_resolver_->Resolve(host,
+                                         ADDRESS_FAMILY_UNSPECIFIED,
+                                         &address_list);
+
+    if (result != OK)
+      return std::string();  // Failed.
+
+    // Stringify all of the addresses in the address list, separated
+    // by semicolons.
+    std::string address_list_str;
+    const struct addrinfo* current_address = address_list.head();
+    while (current_address) {
+      if (!address_list_str.empty())
+        address_list_str += ";";
+      address_list_str += net::NetAddressToString(current_address);
+      current_address = current_address->ai_next;
+    }
+
+    return address_list_str;
+  }
+
   // Handler for when an error is encountered. |line_number| may be -1.
   virtual void OnError(int line_number, const std::string& message) {
     if (line_number == -1)
       LOG(INFO) << "PAC-error: " << message;
     else
       LOG(INFO) << "PAC-error: " << "line: " << line_number << ": " << message;
   }
 
  private:
   scoped_refptr<SyncHostResolverBridge> host_resolver_;
 };
 
 }  // namespace
 
 // static
 ProxyResolverJSBindings* ProxyResolverJSBindings::CreateDefault(
     HostResolver* host_resolver, MessageLoop* host_resolver_loop) {
   return new DefaultJSBindings(host_resolver, host_resolver_loop);
 }
 
 }  // namespace net