1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "chrome/test/chromedriver/net/port_server.h" 6 7 #include "base/bind.h" 8 #include "base/bind_helpers.h" 9 #include "base/logging.h" 10 #include "base/process/process_handle.h" 11 #include "base/rand_util.h" 12 #include "base/strings/string_number_conversions.h" 13 #include "base/sync_socket.h" 14 #include "chrome/test/chromedriver/chrome/status.h" 15 #include "net/base/net_errors.h" 16 #include "net/base/net_log.h" 17 #include "net/base/net_util.h" 18 #include "net/base/sys_addrinfo.h" 19 #include "net/socket/tcp_server_socket.h" 20 21 #if defined(OS_LINUX) 22 #include <sys/socket.h> 23 #include <sys/un.h> 24 #endif 25 26 PortReservation::PortReservation(const base::Closure& on_free_func, int port) 27 : on_free_func_(on_free_func), port_(port) {} 28 29 PortReservation::~PortReservation() { 30 if (!on_free_func_.is_null()) 31 on_free_func_.Run(); 32 } 33 34 void PortReservation::Leak() { 35 LOG(ERROR) << "Port leaked: " << port_; 36 on_free_func_.Reset(); 37 } 38 39 PortServer::PortServer(const std::string& path) : path_(path) { 40 CHECK(path_.size() && path_[0] == 0) 41 << "path must be for Linux abstract namespace"; 42 } 43 44 PortServer::~PortServer() {} 45 46 Status PortServer::ReservePort(int* port, 47 scoped_ptr<PortReservation>* reservation) { 48 int port_to_use = 0; 49 { 50 base::AutoLock lock(free_lock_); 51 if (free_.size()) { 52 port_to_use = free_.front(); 53 free_.pop_front(); 54 } 55 } 56 if (!port_to_use) { 57 Status status = RequestPort(&port_to_use); 58 if (status.IsError()) 59 return status; 60 } 61 *port = port_to_use; 62 reservation->reset(new PortReservation( 63 base::Bind(&PortServer::ReleasePort, base::Unretained(this), port_to_use), 64 port_to_use)); 65 return Status(kOk); 66 } 67 68 Status PortServer::RequestPort(int* port) { 69 // The client sends its PID + \n, and the server responds with a port + \n, 70 // which is valid for the lifetime of the referred process. 71 #if defined(OS_LINUX) 72 int sock_fd = socket(AF_UNIX, SOCK_STREAM, 0); 73 if (sock_fd < 0) 74 return Status(kUnknownError, "unable to create socket"); 75 base::SyncSocket sock(sock_fd); 76 struct timeval tv; 77 tv.tv_sec = 10; 78 tv.tv_usec = 0; 79 if (setsockopt(sock_fd, 80 SOL_SOCKET, 81 SO_RCVTIMEO, 82 reinterpret_cast<char*>(&tv), 83 sizeof(tv)) < 0 || 84 setsockopt(sock_fd, 85 SOL_SOCKET, 86 SO_SNDTIMEO, 87 reinterpret_cast<char*>(&tv), 88 sizeof(tv)) < 0) { 89 return Status(kUnknownError, "unable to set socket timeout"); 90 } 91 92 struct sockaddr_un addr; 93 memset(&addr, 0, sizeof(addr)); 94 addr.sun_family = AF_UNIX; 95 memcpy(addr.sun_path, &path_[0], path_.length()); 96 if (connect(sock.handle(), 97 reinterpret_cast<struct sockaddr*>(&addr), 98 sizeof(sa_family_t) + path_.length())) { 99 return Status(kUnknownError, "unable to connect"); 100 } 101 102 int proc_id = static_cast<int>(base::GetCurrentProcId()); 103 std::string request = base::IntToString(proc_id); 104 request += "\n"; 105 VLOG(0) << "PORTSERVER REQUEST " << request; 106 if (sock.Send(request.c_str(), request.length()) != request.length()) 107 return Status(kUnknownError, "failed to send portserver request"); 108 109 std::string response; 110 do { 111 char c = 0; 112 size_t rv = sock.Receive(&c, 1); 113 if (!rv) 114 break; 115 response.push_back(c); 116 } while (sock.Peek()); 117 if (response.empty()) 118 return Status(kUnknownError, "failed to receive portserver response"); 119 VLOG(0) << "PORTSERVER RESPONSE " << response; 120 121 int new_port = 0; 122 if (*response.rbegin() != '\n' || 123 !base::StringToInt(response.substr(0, response.length() - 1), &new_port)) 124 return Status(kUnknownError, "failed to parse portserver response"); 125 *port = new_port; 126 return Status(kOk); 127 #else 128 return Status(kUnknownError, "not implemented for this platform"); 129 #endif 130 } 131 132 void PortServer::ReleasePort(int port) { 133 base::AutoLock lock(free_lock_); 134 free_.push_back(port); 135 } 136 137 PortManager::PortManager(int min_port, int max_port) 138 : min_port_(min_port), max_port_(max_port) { 139 CHECK_GE(max_port_, min_port_); 140 } 141 142 PortManager::~PortManager() {} 143 144 int PortManager::FindAvailablePort() const { 145 int start = base::RandInt(min_port_, max_port_); 146 bool wrapped = false; 147 for (int try_port = start; try_port != start || !wrapped; ++try_port) { 148 if (try_port > max_port_) { 149 wrapped = true; 150 if (min_port_ == max_port_) 151 break; 152 try_port = min_port_; 153 } 154 if (taken_.count(try_port)) 155 continue; 156 157 char parts[] = {127, 0, 0, 1}; 158 net::IPAddressNumber address(parts, parts + arraysize(parts)); 159 net::NetLog::Source source; 160 net::TCPServerSocket sock(NULL, source); 161 if (sock.Listen(net::IPEndPoint(address, try_port), 1) == net::OK) 162 return try_port; 163 } 164 return 0; 165 } 166 167 Status PortManager::ReservePort(int* port, 168 scoped_ptr<PortReservation>* reservation) { 169 base::AutoLock lock(lock_); 170 int port_to_use = FindAvailablePort(); 171 if (!port_to_use) 172 return Status(kUnknownError, "unable to find open port"); 173 174 taken_.insert(port_to_use); 175 *port = port_to_use; 176 reservation->reset(new PortReservation( 177 base::Bind(&PortManager::ReleasePort, base::Unretained(this), 178 port_to_use), 179 port_to_use)); 180 return Status(kOk); 181 } 182 183 Status PortManager::ReservePortFromPool( 184 int* port, scoped_ptr<PortReservation>* reservation) { 185 base::AutoLock lock(lock_); 186 int port_to_use = 0; 187 if (unused_forwarded_port_.size()) { 188 port_to_use = unused_forwarded_port_.front(); 189 unused_forwarded_port_.pop_front(); 190 } else { 191 port_to_use = FindAvailablePort(); 192 } 193 if (!port_to_use) 194 return Status(kUnknownError, "unable to find open port"); 195 196 taken_.insert(port_to_use); 197 *port = port_to_use; 198 reservation->reset(new PortReservation( 199 base::Bind(&PortManager::ReleasePortToPool, base::Unretained(this), 200 port_to_use), 201 port_to_use)); 202 return Status(kOk); 203 } 204 205 void PortManager::ReleasePort(int port) { 206 base::AutoLock lock(lock_); 207 taken_.erase(port); 208 } 209 210 void PortManager::ReleasePortToPool(int port) { 211 base::AutoLock lock(lock_); 212 taken_.erase(port); 213 unused_forwarded_port_.push_back(port); 214 } 215
