| // Copyright (c) 2012 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. |
| |
| #ifndef NET_TEST_BASE_TEST_SERVER_H_ |
| #define NET_TEST_BASE_TEST_SERVER_H_ |
| #pragma once |
| |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| #include "base/compiler_specific.h" |
| #include "base/file_path.h" |
| #include "base/memory/scoped_ptr.h" |
| #include "net/base/host_port_pair.h" |
| |
| class GURL; |
| |
| namespace base { |
| class DictionaryValue; |
| } |
| |
| namespace net { |
| |
| class AddressList; |
| class ScopedPortException; |
| |
| // The base class of Test server implementation. |
| class BaseTestServer { |
| public: |
| typedef std::pair<std::string, std::string> StringPair; |
| |
| enum Type { |
| TYPE_FTP, |
| TYPE_GDATA, |
| TYPE_HTTP, |
| TYPE_HTTPS, |
| TYPE_SYNC, |
| TYPE_TCP_ECHO, |
| TYPE_UDP_ECHO, |
| }; |
| |
| // Container for various options to control how the HTTPS server is |
| // initialized. |
| struct HTTPSOptions { |
| enum ServerCertificate { |
| CERT_OK, |
| |
| // CERT_AUTO causes the testserver to generate a test certificate issued |
| // by "Testing CA" (see net/data/ssl/certificates/ocsp-test-root.pem). |
| CERT_AUTO, |
| |
| CERT_MISMATCHED_NAME, |
| CERT_EXPIRED, |
| // Cross-signed certificate to test PKIX path building. Contains an |
| // intermediate cross-signed by an unknown root, while the client (via |
| // TestRootStore) is expected to have a self-signed version of the |
| // intermediate. |
| CERT_CHAIN_WRONG_ROOT, |
| }; |
| |
| // OCSPStatus enumerates the types of OCSP response that the testserver |
| // can produce. |
| enum OCSPStatus { |
| OCSP_OK, |
| OCSP_REVOKED, |
| OCSP_INVALID, |
| }; |
| |
| // Bitmask of bulk encryption algorithms that the test server supports |
| // and that can be selectively enabled or disabled. |
| enum BulkCipher { |
| // Special value used to indicate that any algorithm the server supports |
| // is acceptable. Preferred over explicitly OR-ing all ciphers. |
| BULK_CIPHER_ANY = 0, |
| |
| BULK_CIPHER_RC4 = (1 << 0), |
| BULK_CIPHER_AES128 = (1 << 1), |
| BULK_CIPHER_AES256 = (1 << 2), |
| |
| // NOTE: 3DES support in the Python test server has external |
| // dependencies and not be available on all machines. Clients may not |
| // be able to connect if only 3DES is specified. |
| BULK_CIPHER_3DES = (1 << 3), |
| }; |
| |
| // Initialize a new HTTPSOptions using CERT_OK as the certificate. |
| HTTPSOptions(); |
| |
| // Initialize a new HTTPSOptions that will use the specified certificate. |
| explicit HTTPSOptions(ServerCertificate cert); |
| ~HTTPSOptions(); |
| |
| // Returns the relative filename of the file that contains the |
| // |server_certificate|. |
| FilePath GetCertificateFile() const; |
| |
| // GetOCSPArgument returns the value of any OCSP argument to testserver or |
| // the empty string if there is none. |
| std::string GetOCSPArgument() const; |
| |
| // The certificate to use when serving requests. |
| ServerCertificate server_certificate; |
| |
| // If |server_certificate==CERT_AUTO| then this determines the type of OCSP |
| // response returned. |
| OCSPStatus ocsp_status; |
| |
| // True if a CertificateRequest should be sent to the client during |
| // handshaking. |
| bool request_client_certificate; |
| |
| // If |request_client_certificate| is true, an optional list of files, |
| // each containing a single, PEM-encoded X.509 certificates. The subject |
| // from each certificate will be added to the certificate_authorities |
| // field of the CertificateRequest. |
| std::vector<FilePath> client_authorities; |
| |
| // A bitwise-OR of BulkCipher that should be used by the |
| // HTTPS server, or BULK_CIPHER_ANY to indicate that all implemented |
| // ciphers are acceptable. |
| int bulk_ciphers; |
| |
| // If true, pass the --https-record-resume argument to testserver.py which |
| // causes it to log session cache actions and echo the log on |
| // /ssl-session-cache. |
| bool record_resume; |
| }; |
| |
| // Pass as the 'host' parameter during construction to server on 127.0.0.1 |
| static const char kLocalhost[]; |
| |
| // The auth token to be used for TYPE_GDATA server. |
| static const char kGDataAuthToken[]; |
| |
| // Initialize a TestServer listening on a specific host (IP or hostname). |
| BaseTestServer(Type type, const std::string& host); |
| |
| // Initialize a HTTPS TestServer with a specific set of HTTPSOptions. |
| explicit BaseTestServer(const HTTPSOptions& https_options); |
| |
| // Returns the host port pair used by current Python based test server only |
| // if the server is started. |
| const HostPortPair& host_port_pair() const; |
| |
| const FilePath& document_root() const { return document_root_; } |
| const base::DictionaryValue& server_data() const; |
| std::string GetScheme() const; |
| bool GetAddressList(AddressList* address_list) const WARN_UNUSED_RESULT; |
| |
| GURL GetURL(const std::string& path) const; |
| |
| GURL GetURLWithUser(const std::string& path, |
| const std::string& user) const; |
| |
| GURL GetURLWithUserAndPassword(const std::string& path, |
| const std::string& user, |
| const std::string& password) const; |
| |
| static bool GetFilePathWithReplacements( |
| const std::string& original_path, |
| const std::vector<StringPair>& text_to_replace, |
| std::string* replacement_path); |
| |
| protected: |
| virtual ~BaseTestServer(); |
| Type type() const { return type_; } |
| |
| // Gets port currently assigned to host_port_pair_ without checking |
| // whether it's available (server started) or not. |
| uint16 GetPort(); |
| |
| // Sets |port| as the actual port used by Python based test server. |
| void SetPort(uint16 port); |
| |
| // Set up internal status when the server is started. |
| bool SetupWhenServerStarted() WARN_UNUSED_RESULT; |
| |
| // Clean up internal status when starting to stop server. |
| void CleanUpWhenStoppingServer(); |
| |
| // Set path of test resources. |
| void SetResourcePath(const FilePath& document_root, |
| const FilePath& certificates_dir); |
| |
| // Parses the server data read from the test server. Returns true |
| // on success. |
| bool ParseServerData(const std::string& server_data) WARN_UNUSED_RESULT; |
| |
| // Generates a DictionaryValue with the arguments for launching the external |
| // Python test server. |
| bool GenerateArguments(base::DictionaryValue* arguments) const; |
| |
| private: |
| void Init(const std::string& host); |
| |
| // Marks the root certificate of an HTTPS test server as trusted for |
| // the duration of tests. |
| bool LoadTestRootCert() const WARN_UNUSED_RESULT; |
| |
| // Document root of the test server. |
| FilePath document_root_; |
| |
| // Directory that contains the SSL certificates. |
| FilePath certificates_dir_; |
| |
| // Address the test server listens on. |
| HostPortPair host_port_pair_; |
| |
| // Holds the data sent from the server (e.g., port number). |
| scoped_ptr<base::DictionaryValue> server_data_; |
| |
| // If |type_| is TYPE_HTTPS, the TLS settings to use for the test server. |
| HTTPSOptions https_options_; |
| |
| Type type_; |
| |
| // Has the server been started? |
| bool started_; |
| |
| // Enables logging of the server to the console. |
| bool log_to_console_; |
| |
| scoped_ptr<ScopedPortException> allowed_port_; |
| |
| DISALLOW_COPY_AND_ASSIGN(BaseTestServer); |
| }; |
| |
| } // namespace net |
| |
| #endif // NET_TEST_BASE_TEST_SERVER_H_ |
| |