Move DNS resolution from websocket-to-TCP proxy to ExtensionFunction

chrome/browser/chromeos/web_socket_proxy.cc

 // Copyright (c) 2011 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 "chrome/browser/chromeos/web_socket_proxy.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
 #include <limits>
 #include <list>
 #include <map>
 #include <vector>
 
 #include <arpa/inet.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <netinet/in.h>
 #include <signal.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/logging.h"
+#include "base/string_split.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/sha1.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "chrome/browser/internal_auth.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 100 matching lines @@
 std::string FetchAsciiSnippet(uint8* begin, uint8* end, AsciiFilter filter) {
   std::string rv;
   for (; begin < end; ++begin) {
     if (!isascii(*begin))
       return rv;
     rv += filter(*begin);
   }
   return rv;
 }
 
-// Parses "passport:hostname:port:" string.  Returns true on success.
-bool FetchPassportNamePort(
+// Parses "passport:addr:hostname:port:" string.  Returns true on success.
+bool FetchPassportAddrNamePort(
     uint8* begin, uint8* end,
-    std::string* passport, std::string* name, int* port) {
+    std::string* passport, std::string* addr,
+    std::string* hostname, int* port) {
+
   std::string input(begin, end);
-  if (input[input.size() - 1] != ':')
-    return false;
-  input.resize(input.size() - 1);
 
-  size_t pos = input.find_last_of(':');
-  if (pos == std::string::npos)
-    return false;
-  std::string port_str(input, pos + 1);
-  if (port_str.empty())
-    return false;
-  const char kAsciiDigits[] = "0123456789";
-  COMPILE_ASSERT(sizeof(kAsciiDigits) == 10 + 1, mess_with_digits);
-  if (port_str.find_first_not_of(kAsciiDigits) != std::string::npos)
-    return false;
-  if (!base::StringToInt(port_str, port) ||
-      *port < 0 ||
-      *port >= (1 << 16)) {
+  std::vector<std::string> parts;
+  base::SplitString(input, ':', &parts);
+
+  if (parts.size() != 5 || !parts.back().empty()) {
+    LOG(ERROR) << "Wrong format, input" << input;
     return false;
   }
-  input.resize(pos);
 
-  pos = input.find_first_of(':');
-  if (pos == std::string::npos)
+  // Get passport
+  *passport = parts[0];
+  // Get IP address.
+  *addr = parts[1];
+  // Get hostname.
+  *hostname = parts[2];
+  // Get port.
+  if (!base::StringToInt(parts[3], port) || *port < 0 || *port >= (1<<16)) {
+    LOG(ERROR) << "Not a port: " << port << ", input=" << input;
     return false;
-  passport->assign(input, 0, pos);
-  name->assign(input, pos + 1, std::string::npos);
-  return !name->empty();
+  }
+
+  if (passport->empty() || hostname->empty()) {
+    LOG(ERROR) << "Password or hostname is empty, input=" << input;
+    return false;
+  }
+  return true;
 }
 
 std::string FetchExtensionIdFromOrigin(const std::string &origin) {
   GURL url(origin);
   if (url.SchemeIs(chrome::kExtensionScheme))
     return url.host();
   else
     return std::string();
 }
 
@@ skipping 251 matching lines @@
   std::map<std::string, std::string> header_fields_;
 
   // Parameters requested via query component of GET resource.
   std::map<std::string, std::string> requested_parameters_;
 
   // Hostname and port of destination socket.
   // Websocket client supplies them in first data frame (destframe).
   std::string destname_;
   int destport_;
 
+  // Preresolved |destname_| (empty if not pre-resolved).
+  std::string destaddr_;
+
   // Whether TLS over TCP requested.
   bool do_tls_;
 
   // We try to DNS resolve hostname in both IPv4 and IPv6 domains.
   // Track resolution failures here.
   bool destresolution_ipv4_failed_;
   bool destresolution_ipv6_failed_;
 
   // Used to schedule a timeout for initial phase of connection.
   scoped_ptr<struct event> destconnect_timeout_event_;
@@ skipping 832 matching lines @@
     return STATUS_ABORT;
 
   if (!requested_parameters_.empty()) {
     destname_ = requested_parameters_["hostname"];
     int port;
     if (!base::StringToInt(requested_parameters_["port"], &port) ||
         port < 0 || port >= 1 << 16) {
       return STATUS_ABORT;
     }
     destport_ = port;
+    destaddr_ = requested_parameters_["addr"];
     do_tls_ = (requested_parameters_["tls"] == "true");
 
     requested_parameters_["extension_id"] =
         FetchExtensionIdFromOrigin(GetOrigin());
     std::string passport(requested_parameters_["passport"]);
     requested_parameters_.erase("passport");
     if (!browser::InternalAuthVerification::VerifyPassport(
         passport, "web_socket_proxy", requested_parameters_)) {
       return STATUS_ABORT;
     }
@@ skipping 67 matching lines @@
 
   uint8* buf = EVBUFFER_DATA(evb);
   size_t buf_size = EVBUFFER_LENGTH(evb);
   if (buf_size < frame_bytes_remaining_)
     return STATUS_INCOMPLETE;
   for (size_t i = 0; i < buf_size; ++i) {
     buf[i] ^= frame_mask_[frame_mask_index_];
     frame_mask_index_ = (frame_mask_index_ + 1) % 4;
   }
   std::string passport;
-  if (!FetchPassportNamePort(buf, buf + frame_bytes_remaining_,
-                             &passport, &destname_, &destport_)) {
+  if (!FetchPassportAddrNamePort(buf, buf + frame_bytes_remaining_,
+      &passport, &destaddr_, &destname_, &destport_)) {
     return STATUS_ABORT;
   }
   std::map<std::string, std::string> map;
   map["hostname"] = destname_;
   map["port"] = base::IntToString(destport_);
   map["extension_id"] = FetchExtensionIdFromOrigin(GetOrigin());
+  if (!destaddr_.empty())
+    map["addr"] = destaddr_;
   if (!browser::InternalAuthVerification::VerifyPassport(
       passport, "web_socket_proxy", map)) {
     return STATUS_ABORT;
   }
 
   evbuffer_drain(evb, frame_bytes_remaining_);
   frame_bytes_remaining_ = 0;
   return STATUS_OK;
 }
 
@@ skipping 188 matching lines @@
       case PHASE_WAIT_DESTFRAME: {
         switch (cs->ConsumeDestframe(EVBUFFER_INPUT(bev))) {
           case STATUS_OK: {
             {
               // Unfortunately libevent as of 1.4 does not look into /etc/hosts.
               // There seems to be no easy API to perform only "local" part of
               // getaddrinfo resolution.  Hence this hack for "localhost".
               if (cs->destname_ == "localhost")
                 cs->destname_ = "127.0.0.1";
             }
+            if (cs->destaddr_.empty())
+              cs->destaddr_ = cs->destname_;
             {
               struct sockaddr_in sa;
               memset(&sa, 0, sizeof(sa));
               sa.sin_port = htons(cs->destport_);
               if (inet_pton(sa.sin_family = AF_INET,
-                            cs->destname_.c_str(),
+                            cs->destaddr_.c_str(),
                             &sa.sin_addr) == 1) {
                 // valid IPv4 address supplied.
                 if (cs->TryConnectDest((struct sockaddr*)&sa, sizeof(sa))) {
                   cs->phase_ = PHASE_WAIT_DESTCONNECT;
                   return;
                 }
               }
             }
             {
-              if (cs->destname_.size() >= 2 &&
-                  cs->destname_[0] == '[' &&
-                  cs->destname_[cs->destname_.size() - 1] == ']') {
+              if (cs->destaddr_.size() >= 2 &&
+                  cs->destaddr_[0] == '[' &&
+                  cs->destaddr_[cs->destaddr_.size() - 1] == ']') {
                 // Literal IPv6 address in brackets.
-                cs->destname_ =
-                    cs->destname_.substr(1, cs->destname_.size() - 2);
+                cs->destaddr_ =
+                    cs->destaddr_.substr(1, cs->destaddr_.size() - 2);
               }
               struct sockaddr_in6 sa;
               memset(&sa, 0, sizeof(sa));
               sa.sin6_port = htons(cs->destport_);
               if (inet_pton(sa.sin6_family = AF_INET6,
-                            cs->destname_.c_str(),
+                            cs->destaddr_.c_str(),
                             &sa.sin6_addr) == 1) {
                 // valid IPv6 address supplied.
                 if (cs->TryConnectDest((struct sockaddr*)&sa, sizeof(sa))) {
                   cs->phase_ = PHASE_WAIT_DESTCONNECT;
                   return;
                 }
               }
             }
             // Asynchronous DNS resolution.
             if (evdns_count_nameservers() < 1) {
@@ skipping 284 matching lines @@
 
 void WebSocketProxy::Shutdown() {
   static_cast<Serv*>(impl_)->Shutdown();
 }
 
 void WebSocketProxy::OnNetworkChange() {
   static_cast<Serv*>(impl_)->OnNetworkChange();
 }
 
 }  // namespace chromeos