1 // Copyright 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 "net/test/spawned_test_server/base_test_server.h" 6 7 #include <string> 8 #include <vector> 9 10 #include "base/base64.h" 11 #include "base/file_util.h" 12 #include "base/json/json_reader.h" 13 #include "base/logging.h" 14 #include "base/path_service.h" 15 #include "base/values.h" 16 #include "net/base/address_list.h" 17 #include "net/base/host_port_pair.h" 18 #include "net/base/net_errors.h" 19 #include "net/base/net_log.h" 20 #include "net/base/net_util.h" 21 #include "net/base/test_completion_callback.h" 22 #include "net/cert/test_root_certs.h" 23 #include "net/dns/host_resolver.h" 24 #include "url/gurl.h" 25 26 namespace net { 27 28 namespace { 29 30 std::string GetHostname(BaseTestServer::Type type, 31 const BaseTestServer::SSLOptions& options) { 32 if (BaseTestServer::UsingSSL(type) && 33 options.server_certificate == 34 BaseTestServer::SSLOptions::CERT_MISMATCHED_NAME) { 35 // Return a different hostname string that resolves to the same hostname. 36 return "localhost"; 37 } 38 39 // Use the 127.0.0.1 as default. 40 return BaseTestServer::kLocalhost; 41 } 42 43 void GetCiphersList(int cipher, base::ListValue* values) { 44 if (cipher & BaseTestServer::SSLOptions::BULK_CIPHER_RC4) 45 values->Append(new base::StringValue("rc4")); 46 if (cipher & BaseTestServer::SSLOptions::BULK_CIPHER_AES128) 47 values->Append(new base::StringValue("aes128")); 48 if (cipher & BaseTestServer::SSLOptions::BULK_CIPHER_AES256) 49 values->Append(new base::StringValue("aes256")); 50 if (cipher & BaseTestServer::SSLOptions::BULK_CIPHER_3DES) 51 values->Append(new base::StringValue("3des")); 52 } 53 54 } // namespace 55 56 BaseTestServer::SSLOptions::SSLOptions() 57 : server_certificate(CERT_OK), 58 ocsp_status(OCSP_OK), 59 cert_serial(0), 60 request_client_certificate(false), 61 bulk_ciphers(SSLOptions::BULK_CIPHER_ANY), 62 record_resume(false), 63 tls_intolerant(TLS_INTOLERANT_NONE) {} 64 65 BaseTestServer::SSLOptions::SSLOptions( 66 BaseTestServer::SSLOptions::ServerCertificate cert) 67 : server_certificate(cert), 68 ocsp_status(OCSP_OK), 69 cert_serial(0), 70 request_client_certificate(false), 71 bulk_ciphers(SSLOptions::BULK_CIPHER_ANY), 72 record_resume(false), 73 tls_intolerant(TLS_INTOLERANT_NONE) {} 74 75 BaseTestServer::SSLOptions::~SSLOptions() {} 76 77 base::FilePath BaseTestServer::SSLOptions::GetCertificateFile() const { 78 switch (server_certificate) { 79 case CERT_OK: 80 case CERT_MISMATCHED_NAME: 81 return base::FilePath(FILE_PATH_LITERAL("ok_cert.pem")); 82 case CERT_EXPIRED: 83 return base::FilePath(FILE_PATH_LITERAL("expired_cert.pem")); 84 case CERT_CHAIN_WRONG_ROOT: 85 // This chain uses its own dedicated test root certificate to avoid 86 // side-effects that may affect testing. 87 return base::FilePath(FILE_PATH_LITERAL("redundant-server-chain.pem")); 88 case CERT_AUTO: 89 return base::FilePath(); 90 default: 91 NOTREACHED(); 92 } 93 return base::FilePath(); 94 } 95 96 std::string BaseTestServer::SSLOptions::GetOCSPArgument() const { 97 if (server_certificate != CERT_AUTO) 98 return std::string(); 99 100 switch (ocsp_status) { 101 case OCSP_OK: 102 return "ok"; 103 case OCSP_REVOKED: 104 return "revoked"; 105 case OCSP_INVALID: 106 return "invalid"; 107 case OCSP_UNAUTHORIZED: 108 return "unauthorized"; 109 case OCSP_UNKNOWN: 110 return "unknown"; 111 default: 112 NOTREACHED(); 113 return std::string(); 114 } 115 } 116 117 const char BaseTestServer::kLocalhost[] = "127.0.0.1"; 118 119 BaseTestServer::BaseTestServer(Type type, const std::string& host) 120 : type_(type), 121 started_(false), 122 log_to_console_(false) { 123 Init(host); 124 } 125 126 BaseTestServer::BaseTestServer(Type type, const SSLOptions& ssl_options) 127 : ssl_options_(ssl_options), 128 type_(type), 129 started_(false), 130 log_to_console_(false) { 131 DCHECK(UsingSSL(type)); 132 Init(GetHostname(type, ssl_options)); 133 } 134 135 BaseTestServer::~BaseTestServer() {} 136 137 const HostPortPair& BaseTestServer::host_port_pair() const { 138 DCHECK(started_); 139 return host_port_pair_; 140 } 141 142 const base::DictionaryValue& BaseTestServer::server_data() const { 143 DCHECK(started_); 144 DCHECK(server_data_.get()); 145 return *server_data_; 146 } 147 148 std::string BaseTestServer::GetScheme() const { 149 switch (type_) { 150 case TYPE_FTP: 151 return "ftp"; 152 case TYPE_HTTP: 153 return "http"; 154 case TYPE_HTTPS: 155 return "https"; 156 case TYPE_WS: 157 return "ws"; 158 case TYPE_WSS: 159 return "wss"; 160 case TYPE_TCP_ECHO: 161 case TYPE_UDP_ECHO: 162 default: 163 NOTREACHED(); 164 } 165 return std::string(); 166 } 167 168 bool BaseTestServer::GetAddressList(AddressList* address_list) const { 169 DCHECK(address_list); 170 171 scoped_ptr<HostResolver> resolver(HostResolver::CreateDefaultResolver(NULL)); 172 HostResolver::RequestInfo info(host_port_pair_); 173 TestCompletionCallback callback; 174 int rv = resolver->Resolve(info, address_list, callback.callback(), NULL, 175 BoundNetLog()); 176 if (rv == ERR_IO_PENDING) 177 rv = callback.WaitForResult(); 178 if (rv != net::OK) { 179 LOG(ERROR) << "Failed to resolve hostname: " << host_port_pair_.host(); 180 return false; 181 } 182 return true; 183 } 184 185 uint16 BaseTestServer::GetPort() { 186 return host_port_pair_.port(); 187 } 188 189 void BaseTestServer::SetPort(uint16 port) { 190 host_port_pair_.set_port(port); 191 } 192 193 GURL BaseTestServer::GetURL(const std::string& path) const { 194 return GURL(GetScheme() + "://" + host_port_pair_.ToString() + "/" + path); 195 } 196 197 GURL BaseTestServer::GetURLWithUser(const std::string& path, 198 const std::string& user) const { 199 return GURL(GetScheme() + "://" + user + "@" + host_port_pair_.ToString() + 200 "/" + path); 201 } 202 203 GURL BaseTestServer::GetURLWithUserAndPassword(const std::string& path, 204 const std::string& user, 205 const std::string& password) const { 206 return GURL(GetScheme() + "://" + user + ":" + password + "@" + 207 host_port_pair_.ToString() + "/" + path); 208 } 209 210 // static 211 bool BaseTestServer::GetFilePathWithReplacements( 212 const std::string& original_file_path, 213 const std::vector<StringPair>& text_to_replace, 214 std::string* replacement_path) { 215 std::string new_file_path = original_file_path; 216 bool first_query_parameter = true; 217 const std::vector<StringPair>::const_iterator end = text_to_replace.end(); 218 for (std::vector<StringPair>::const_iterator it = text_to_replace.begin(); 219 it != end; 220 ++it) { 221 const std::string& old_text = it->first; 222 const std::string& new_text = it->second; 223 std::string base64_old; 224 std::string base64_new; 225 if (!base::Base64Encode(old_text, &base64_old)) 226 return false; 227 if (!base::Base64Encode(new_text, &base64_new)) 228 return false; 229 if (first_query_parameter) { 230 new_file_path += "?"; 231 first_query_parameter = false; 232 } else { 233 new_file_path += "&"; 234 } 235 new_file_path += "replace_text="; 236 new_file_path += base64_old; 237 new_file_path += ":"; 238 new_file_path += base64_new; 239 } 240 241 *replacement_path = new_file_path; 242 return true; 243 } 244 245 void BaseTestServer::Init(const std::string& host) { 246 host_port_pair_ = HostPortPair(host, 0); 247 248 // TODO(battre) Remove this after figuring out why the TestServer is flaky. 249 // http://crbug.com/96594 250 log_to_console_ = true; 251 } 252 253 void BaseTestServer::SetResourcePath(const base::FilePath& document_root, 254 const base::FilePath& certificates_dir) { 255 // This method shouldn't get called twice. 256 DCHECK(certificates_dir_.empty()); 257 document_root_ = document_root; 258 certificates_dir_ = certificates_dir; 259 DCHECK(!certificates_dir_.empty()); 260 } 261 262 bool BaseTestServer::ParseServerData(const std::string& server_data) { 263 VLOG(1) << "Server data: " << server_data; 264 base::JSONReader json_reader; 265 scoped_ptr<base::Value> value(json_reader.ReadToValue(server_data)); 266 if (!value.get() || !value->IsType(base::Value::TYPE_DICTIONARY)) { 267 LOG(ERROR) << "Could not parse server data: " 268 << json_reader.GetErrorMessage(); 269 return false; 270 } 271 272 server_data_.reset(static_cast<base::DictionaryValue*>(value.release())); 273 int port = 0; 274 if (!server_data_->GetInteger("port", &port)) { 275 LOG(ERROR) << "Could not find port value"; 276 return false; 277 } 278 if ((port <= 0) || (port > kuint16max)) { 279 LOG(ERROR) << "Invalid port value: " << port; 280 return false; 281 } 282 host_port_pair_.set_port(port); 283 284 return true; 285 } 286 287 bool BaseTestServer::LoadTestRootCert() const { 288 TestRootCerts* root_certs = TestRootCerts::GetInstance(); 289 if (!root_certs) 290 return false; 291 292 // Should always use absolute path to load the root certificate. 293 base::FilePath root_certificate_path = certificates_dir_; 294 if (!certificates_dir_.IsAbsolute()) { 295 base::FilePath src_dir; 296 if (!PathService::Get(base::DIR_SOURCE_ROOT, &src_dir)) 297 return false; 298 root_certificate_path = src_dir.Append(certificates_dir_); 299 } 300 301 return root_certs->AddFromFile( 302 root_certificate_path.AppendASCII("root_ca_cert.pem")); 303 } 304 305 bool BaseTestServer::SetupWhenServerStarted() { 306 DCHECK(host_port_pair_.port()); 307 308 if (UsingSSL(type_) && !LoadTestRootCert()) 309 return false; 310 311 started_ = true; 312 allowed_port_.reset(new ScopedPortException(host_port_pair_.port())); 313 return true; 314 } 315 316 void BaseTestServer::CleanUpWhenStoppingServer() { 317 TestRootCerts* root_certs = TestRootCerts::GetInstance(); 318 root_certs->Clear(); 319 320 host_port_pair_.set_port(0); 321 allowed_port_.reset(); 322 started_ = false; 323 } 324 325 // Generates a dictionary of arguments to pass to the Python test server via 326 // the test server spawner, in the form of 327 // { argument-name: argument-value, ... } 328 // Returns false if an invalid configuration is specified. 329 bool BaseTestServer::GenerateArguments(base::DictionaryValue* arguments) const { 330 DCHECK(arguments); 331 332 arguments->SetString("host", host_port_pair_.host()); 333 arguments->SetInteger("port", host_port_pair_.port()); 334 arguments->SetString("data-dir", document_root_.value()); 335 336 if (VLOG_IS_ON(1) || log_to_console_) 337 arguments->Set("log-to-console", base::Value::CreateNullValue()); 338 339 if (UsingSSL(type_)) { 340 // Check the certificate arguments of the HTTPS server. 341 base::FilePath certificate_path(certificates_dir_); 342 base::FilePath certificate_file(ssl_options_.GetCertificateFile()); 343 if (!certificate_file.value().empty()) { 344 certificate_path = certificate_path.Append(certificate_file); 345 if (certificate_path.IsAbsolute() && 346 !base::PathExists(certificate_path)) { 347 LOG(ERROR) << "Certificate path " << certificate_path.value() 348 << " doesn't exist. Can't launch https server."; 349 return false; 350 } 351 arguments->SetString("cert-and-key-file", certificate_path.value()); 352 } 353 354 // Check the client certificate related arguments. 355 if (ssl_options_.request_client_certificate) 356 arguments->Set("ssl-client-auth", base::Value::CreateNullValue()); 357 scoped_ptr<base::ListValue> ssl_client_certs(new base::ListValue()); 358 359 std::vector<base::FilePath>::const_iterator it; 360 for (it = ssl_options_.client_authorities.begin(); 361 it != ssl_options_.client_authorities.end(); ++it) { 362 if (it->IsAbsolute() && !base::PathExists(*it)) { 363 LOG(ERROR) << "Client authority path " << it->value() 364 << " doesn't exist. Can't launch https server."; 365 return false; 366 } 367 ssl_client_certs->Append(new base::StringValue(it->value())); 368 } 369 370 if (ssl_client_certs->GetSize()) 371 arguments->Set("ssl-client-ca", ssl_client_certs.release()); 372 } 373 374 if (type_ == TYPE_HTTPS) { 375 arguments->Set("https", base::Value::CreateNullValue()); 376 377 std::string ocsp_arg = ssl_options_.GetOCSPArgument(); 378 if (!ocsp_arg.empty()) 379 arguments->SetString("ocsp", ocsp_arg); 380 381 if (ssl_options_.cert_serial != 0) { 382 arguments->Set("cert-serial", 383 base::Value::CreateIntegerValue(ssl_options_.cert_serial)); 384 } 385 386 // Check bulk cipher argument. 387 scoped_ptr<base::ListValue> bulk_cipher_values(new base::ListValue()); 388 GetCiphersList(ssl_options_.bulk_ciphers, bulk_cipher_values.get()); 389 if (bulk_cipher_values->GetSize()) 390 arguments->Set("ssl-bulk-cipher", bulk_cipher_values.release()); 391 if (ssl_options_.record_resume) 392 arguments->Set("https-record-resume", base::Value::CreateNullValue()); 393 if (ssl_options_.tls_intolerant != SSLOptions::TLS_INTOLERANT_NONE) { 394 arguments->Set("tls-intolerant", 395 new base::FundamentalValue(ssl_options_.tls_intolerant)); 396 } 397 } 398 399 return GenerateAdditionalArguments(arguments); 400 } 401 402 bool BaseTestServer::GenerateAdditionalArguments( 403 base::DictionaryValue* arguments) const { 404 return true; 405 } 406 407 } // namespace net 408