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