Pass a user agent string to WinHttpOpen to set the user...

net/http/http_transaction_winhttp.cc

 // Copyright (c) 2006-2008 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 "net/http/http_transaction_winhttp.h"
 
 #include <winhttp.h>
 
 #include "base/lock.h"
 #include "base/memory_debug.h"
@@ skipping 154 matching lines @@
 
 class HttpTransactionWinHttp::Session
   : public base::RefCounted<HttpTransactionWinHttp::Session> {
  public:
   enum {
     // By default WinHTTP enables only SSL3 and TLS1.
     SECURE_PROTOCOLS_SSL3_TLS1 = WINHTTP_FLAG_SECURE_PROTOCOL_SSL3 |
                                  WINHTTP_FLAG_SECURE_PROTOCOL_TLS1
   };
 
-  Session()
-      : internet_(NULL),
-        internet_no_tls_(NULL),
-        message_loop_(NULL),
-        handle_closing_event_(NULL),
-        quit_event_(NULL),
-        session_callback_ref_count_(0),
-        quitting_(false),
-        rev_checking_enabled_(false),
-        secure_protocols_(SECURE_PROTOCOLS_SSL3_TLS1) {
-  }
+  Session();
 
-  bool Init();
+  // Opens the primary WinHttp session handle.
+  bool Init(const std::string& user_agent);
 
   // Opens the alternative WinHttp session handle for TLS-intolerant servers.
-  bool InitNoTLS();
+  bool InitNoTLS(const std::string& user_agent);
 
   void AddRefBySessionCallback();
 
   void ReleaseBySessionCallback();
 
   // The primary WinHttp session handle.
   HINTERNET internet() { return internet_; }
 
   // An alternative WinHttp session handle.  It is not opened until we have
   // encountered a TLS-intolerant server and used for those servers only.
@@ skipping 32 matching lines @@
   }
 
  private:
   friend class base::RefCounted<HttpTransactionWinHttp::Session>;
 
   ~Session();
 
   // Called by the destructor only.
   void WaitUntilCallbacksAllDone();
 
-  HINTERNET OpenWinHttpSession();
+  HINTERNET OpenWinHttpSession(const std::string& user_agent);
 
-  // Get the SSL configuration settings and apply them to the session handle.
-  void ConfigureSSL();
+  // Get the SSL configuration settings and save them in rev_checking_enabled_
+  // and secure_protocols_.
+  void GetSSLConfig();
 
   HINTERNET internet_;
   HINTERNET internet_no_tls_;
   MessageLoop* message_loop_;
   scoped_ptr<ProxyService> proxy_service_;
   scoped_ptr<ProxyResolver> proxy_resolver_;
   AuthCache auth_cache_;
 
   // This event object is used when destroying a transaction.  It is given
   // to the transaction's session callback if WinHTTP still has the caller's
@@ skipping 40 matching lines @@
   // the session, we will have to remember all the servers we have visited
   // while the rev_checking_enabled setting is false.  This will consume a
   // lot of memory.  So we now require the users to restart Chrome for a
   // rev_checking_enabled change to take effect, just like IE does.
   typedef std::set<std::string> OriginSet;
   OriginSet ignore_cert_rev_servers_;
 
   WinHttpRequestThrottle request_throttle_;
 };
 
+HttpTransactionWinHttp::Session::Session()
+    : internet_(NULL),
+      internet_no_tls_(NULL),
+      session_callback_ref_count_(0),
+      quitting_(false) {
+  proxy_resolver_.reset(new ProxyResolverWinHttp());
+  proxy_service_.reset(new ProxyService(proxy_resolver_.get()));
+
+  GetSSLConfig();
+
+  // Save the current message loop for callback notifications.
+  message_loop_ = MessageLoop::current();
+
+  handle_closing_event_ = CreateEvent(NULL,
+                                      FALSE,  // auto-reset
+                                      FALSE,  // initially nonsignaled
+                                      NULL);  // unnamed
+
+  quit_event_ = CreateEvent(NULL,
+                            FALSE,  // auto-reset
+                            FALSE,  // initially nonsignaled
+                            NULL);  // unnamed
+}
+
 HttpTransactionWinHttp::Session::~Session() {
   // It is important to shutdown the proxy service before closing the WinHTTP
   // session handle since the proxy service uses the WinHTTP session handle.
   proxy_service_.reset();
 
   // Next, the resolver which also references our session handle.
   proxy_resolver_.reset();
 
   if (internet_) {
     WinHttpCloseHandle(internet_);
     if (internet_no_tls_)
       WinHttpCloseHandle(internet_no_tls_);
 
     // Ensure that all status callbacks that may reference the MessageLoop
     // of this thread are done before we can allow the current thread to exit.
     WaitUntilCallbacksAllDone();
   }
 
   if (handle_closing_event_)
     CloseHandle(handle_closing_event_);
   if (quit_event_)
     CloseHandle(quit_event_);
 }
 
-bool HttpTransactionWinHttp::Session::Init() {
+bool HttpTransactionWinHttp::Session::Init(const std::string& user_agent) {
   DCHECK(!internet_);
 
-  internet_ = OpenWinHttpSession();
+  internet_ = OpenWinHttpSession(user_agent);
 
   if (!internet_)
     return false;
 
-  proxy_resolver_.reset(new ProxyResolverWinHttp());
-  proxy_service_.reset(new ProxyService(proxy_resolver_.get()));
-
-  ConfigureSSL();
-
-  // Save the current message loop for callback notifications.
-  message_loop_ = MessageLoop::current();
-
-  handle_closing_event_ = CreateEvent(NULL,
-                                      FALSE,  // auto-reset
-                                      FALSE,  // initially nonsignaled
-                                      NULL);  // unnamed
-
-  quit_event_ = CreateEvent(NULL,
-                            FALSE,  // auto-reset
-                            FALSE,  // initially nonsignaled
-                            NULL);  // unnamed
+  if (secure_protocols_ != SECURE_PROTOCOLS_SSL3_TLS1) {
+    BOOL rv = WinHttpSetOption(internet_, WINHTTP_OPTION_SECURE_PROTOCOLS,
+                               &secure_protocols_, sizeof(secure_protocols_));
+    DCHECK(rv);
+  }
 
   return true;
 }
 
-bool HttpTransactionWinHttp::Session::InitNoTLS() {
+bool HttpTransactionWinHttp::Session::InitNoTLS(
+    const std::string& user_agent) {
   DCHECK(tls_enabled());
   DCHECK(internet_);
   DCHECK(!internet_no_tls_);
 
-  internet_no_tls_ = OpenWinHttpSession();
+  internet_no_tls_ = OpenWinHttpSession(user_agent);
 
   if (!internet_no_tls_)
     return false;
 
   DWORD protocols = secure_protocols_ & ~WINHTTP_FLAG_SECURE_PROTOCOL_TLS1;
   BOOL rv = WinHttpSetOption(internet_no_tls_,
                              WINHTTP_OPTION_SECURE_PROTOCOLS,
                              &protocols, sizeof(protocols));
   DCHECK(rv);
 
@@ skipping 26 matching lines @@
   {
     AutoLock lock(lock_);
     quitting_ = true;
     need_to_wait = (session_callback_ref_count_ != 0);
   }
   if (need_to_wait)
     WaitForSingleObject(quit_event_, INFINITE);
   DCHECK(session_callback_ref_count_ == 0);
 }
 
-HINTERNET HttpTransactionWinHttp::Session::OpenWinHttpSession() {
-  // UA string and proxy config will be set explicitly for each request
-  HINTERNET internet = WinHttpOpen(NULL,
+HINTERNET HttpTransactionWinHttp::Session::OpenWinHttpSession(
+    const std::string& user_agent) {
+  // Proxy config will be set explicitly for each request.
+  //
+  // Although UA string will also be set explicitly for each request, HTTP
+  // CONNECT requests use the UA string of the session handle, so we have to
+  // pass a UA string to WinHttpOpen.
+  HINTERNET internet = WinHttpOpen(ASCIIToWide(user_agent).c_str(),
                                    WINHTTP_ACCESS_TYPE_NO_PROXY,
                                    WINHTTP_NO_PROXY_NAME,
                                    WINHTTP_NO_PROXY_BYPASS,
                                    WINHTTP_FLAG_ASYNC);
   if (!internet)
     return internet;
 
   // Use a 90-second timeout (1.5 times the default) for connect.  Disable
   // name resolution, send, and receive timeouts.  We expect our consumer to
   // apply timeouts or provide controls for users to stop requests that are
   // taking too long.
   BOOL rv = WinHttpSetTimeouts(internet, 0, 90000, 0, 0);
   DCHECK(rv);
 
   return internet;
 }
 
-void HttpTransactionWinHttp::Session::ConfigureSSL() {
-  DCHECK(internet_);
-
+void HttpTransactionWinHttp::Session::GetSSLConfig() {
   SSLConfig ssl_config;
   SSLConfigService::GetSSLConfigNow(&ssl_config);
   rev_checking_enabled_ = ssl_config.rev_checking_enabled;
-  DWORD protocols = 0;
+  secure_protocols_ = 0;
   if (ssl_config.ssl2_enabled)
-    protocols |= WINHTTP_FLAG_SECURE_PROTOCOL_SSL2;
+    secure_protocols_ |= WINHTTP_FLAG_SECURE_PROTOCOL_SSL2;
   if (ssl_config.ssl3_enabled)
-    protocols |= WINHTTP_FLAG_SECURE_PROTOCOL_SSL3;
+    secure_protocols_ |= WINHTTP_FLAG_SECURE_PROTOCOL_SSL3;
   if (ssl_config.tls1_enabled)
-    protocols |= WINHTTP_FLAG_SECURE_PROTOCOL_TLS1;
-  if (protocols != secure_protocols_) {
-    BOOL rv = WinHttpSetOption(internet_, WINHTTP_OPTION_SECURE_PROTOCOLS,
-                               &protocols, sizeof(protocols));
-    DCHECK(rv);
-    secure_protocols_ = protocols;
-  }
+    secure_protocols_ |= WINHTTP_FLAG_SECURE_PROTOCOL_TLS1;
 }
 
 // SessionCallback ------------------------------------------------------------
 
 class HttpTransactionWinHttp::SessionCallback
   : public base::RefCountedThreadSafe<HttpTransactionWinHttp::SessionCallback> {
  public:
   SessionCallback(HttpTransactionWinHttp* trans, Session* session)
       : trans_(trans),
         session_(session),
@@ skipping 274 matching lines @@
     session_->Release();
 }
 
 HttpTransaction* HttpTransactionWinHttp::Factory::CreateTransaction() {
   if (is_suspended_)
     return NULL;
 
   if (!session_) {
     session_ = new Session();
     session_->AddRef();
-    if (!session_->Init()) {
-      DLOG(ERROR) << "unable to create the internet";
-      session_->Release();
-      session_ = NULL;
-      return NULL;
-    }
   }
   return new HttpTransactionWinHttp(session_, proxy_info_.get());
 }
 
 HttpCache* HttpTransactionWinHttp::Factory::GetCache() {
   return NULL;
 }
 
 AuthCache* HttpTransactionWinHttp::Factory::GetAuthCache() {
   return session_->auth_cache();
@@ skipping 294 matching lines @@
   }
 
   const std::string& host = url.host();
 
   // Use the primary session handle unless we are talking to a TLS-intolerant
   // server.
   //
   // Since the SSL protocol versions enabled are an option of a session
   // handle, supporting TLS-intolerant servers unfortunately requires opening
   // an alternative session in which TLS 1.0 is disabled.
+  if (!session_->internet() && !session_->Init(request_->user_agent)) {
+    DLOG(ERROR) << "unable to create the internet";
+    return false;
+  }
   HINTERNET internet = session_->internet();
   if (is_tls_intolerant_) {
-    if (!session_->internet_no_tls() && !session_->InitNoTLS()) {
+    if (!session_->internet_no_tls() &&
+        !session_->InitNoTLS(request_->user_agent)) {
       DLOG(ERROR) << "unable to create the no-TLS alternative internet";
       return false;
     }
     internet = session_->internet_no_tls();
   }
 
   // This function operates synchronously.
   connect_handle_ =
       WinHttpConnect(internet, ASCIIToWide(host).c_str(), port, 0);
   if (!connect_handle_) {
@@ skipping 710 matching lines @@
 
   if (rv == ERR_IO_PENDING) {
     session_callback_->AddRef();  // balanced when callback runs.
   } else if (callback_) {
     DoCallback(rv);
   }
 }
 
 }  // namespace net