net/http/http_auth_handler_factory.cc

   1 // Copyright (c) 2010 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/http/http_auth_handler_factory.h"
   6
   7 #include "base/stl_util.h"
   8 #include "base/strings/string_util.h"
   9 #include "net/base/net_errors.h"
  10 #include "net/http/http_auth_filter.h"
  11 #include "net/http/http_auth_handler_basic.h"
  12 #include "net/http/http_auth_handler_digest.h"
  13 #include "net/http/http_auth_handler_ntlm.h"
  14
  15 #if defined(USE_KERBEROS)
  16 #include "net/http/http_auth_handler_negotiate.h"
  17 #endif
  18
  19 namespace net {
  20
  21 int HttpAuthHandlerFactory::CreateAuthHandlerFromString(
  22     const std::string& challenge,
  23     HttpAuth::Target target,
  24     const GURL& origin,
  25     const BoundNetLog& net_log,
  26     scoped_ptr<HttpAuthHandler>* handler) {
  27   HttpAuth::ChallengeTokenizer props(challenge.begin(), challenge.end());
  28   return CreateAuthHandler(&props, target, origin, CREATE_CHALLENGE, 1,
  29                            net_log, handler);
  30 }
  31
  32 int HttpAuthHandlerFactory::CreatePreemptiveAuthHandlerFromString(
  33     const std::string& challenge,
  34     HttpAuth::Target target,
  35     const GURL& origin,
  36     int digest_nonce_count,
  37     const BoundNetLog& net_log,
  38     scoped_ptr<HttpAuthHandler>* handler) {
  39   HttpAuth::ChallengeTokenizer props(challenge.begin(), challenge.end());
  40   return CreateAuthHandler(&props, target, origin, CREATE_PREEMPTIVE,
  41                            digest_nonce_count, net_log, handler);
  42 }
  43
  44 // static
  45 HttpAuthHandlerRegistryFactory* HttpAuthHandlerFactory::CreateDefault(
  46     HostResolver* host_resolver) {
  47   DCHECK(host_resolver);
  48   HttpAuthHandlerRegistryFactory* registry_factory =
  49       new HttpAuthHandlerRegistryFactory();
  50   registry_factory->RegisterSchemeFactory(
  51       "basic", new HttpAuthHandlerBasic::Factory());
  52   registry_factory->RegisterSchemeFactory(
  53       "digest", new HttpAuthHandlerDigest::Factory());
  54
  55 #if defined(USE_KERBEROS)
  56   HttpAuthHandlerNegotiate::Factory* negotiate_factory =
  57       new HttpAuthHandlerNegotiate::Factory();
  58 #if defined(OS_POSIX)
  59   negotiate_factory->set_library(new GSSAPISharedLibrary(std::string()));
  60 #elif defined(OS_WIN)
  61   negotiate_factory->set_library(new SSPILibraryDefault());
  62 #endif
  63   negotiate_factory->set_host_resolver(host_resolver);
  64   registry_factory->RegisterSchemeFactory("negotiate", negotiate_factory);
  65 #endif  // defined(USE_KERBEROS)
  66
  67   HttpAuthHandlerNTLM::Factory* ntlm_factory =
  68       new HttpAuthHandlerNTLM::Factory();
  69 #if defined(OS_WIN)
  70   ntlm_factory->set_sspi_library(new SSPILibraryDefault());
  71 #endif
  72   registry_factory->RegisterSchemeFactory("ntlm", ntlm_factory);
  73   return registry_factory;
  74 }
  75
  76 namespace {
  77
  78 bool IsSupportedScheme(const std::vector<std::string>& supported_schemes,
  79                        const std::string& scheme) {
  80   std::vector<std::string>::const_iterator it = std::find(
  81       supported_schemes.begin(), supported_schemes.end(), scheme);
  82   return it != supported_schemes.end();
  83 }
  84
  85 }  // namespace
  86
  87 HttpAuthHandlerRegistryFactory::HttpAuthHandlerRegistryFactory() {
  88 }
  89
  90 HttpAuthHandlerRegistryFactory::~HttpAuthHandlerRegistryFactory() {
  91   STLDeleteContainerPairSecondPointers(factory_map_.begin(),
  92                                        factory_map_.end());
  93 }
  94
  95 void HttpAuthHandlerRegistryFactory::SetURLSecurityManager(
  96     const std::string& scheme,
  97     URLSecurityManager* security_manager) {
  98   HttpAuthHandlerFactory* factory = GetSchemeFactory(scheme);
  99   if (factory)
 100     factory->set_url_security_manager(security_manager);
 101 }
 102
 103 void HttpAuthHandlerRegistryFactory::RegisterSchemeFactory(
 104     const std::string& scheme,
 105     HttpAuthHandlerFactory* factory) {
 106   std::string lower_scheme = StringToLowerASCII(scheme);
 107   FactoryMap::iterator it = factory_map_.find(lower_scheme);
 108   if (it != factory_map_.end()) {
 109     delete it->second;
 110   }
 111   if (factory)
 112     factory_map_[lower_scheme] = factory;
 113   else
 114     factory_map_.erase(it);
 115 }
 116
 117 HttpAuthHandlerFactory* HttpAuthHandlerRegistryFactory::GetSchemeFactory(
 118     const std::string& scheme) const {
 119   std::string lower_scheme = StringToLowerASCII(scheme);
 120   FactoryMap::const_iterator it = factory_map_.find(lower_scheme);
 121   if (it == factory_map_.end()) {
 122     return NULL;                  // |scheme| is not registered.
 123   }
 124   return it->second;
 125 }
 126
 127 // static
 128 HttpAuthHandlerRegistryFactory* HttpAuthHandlerRegistryFactory::Create(
 129     const std::vector<std::string>& supported_schemes,
 130     URLSecurityManager* security_manager,
 131     HostResolver* host_resolver,
 132     const std::string& gssapi_library_name,
 133     bool negotiate_disable_cname_lookup,
 134     bool negotiate_enable_port) {
 135   HttpAuthHandlerRegistryFactory* registry_factory =
 136       new HttpAuthHandlerRegistryFactory();
 137   if (IsSupportedScheme(supported_schemes, "basic"))
 138     registry_factory->RegisterSchemeFactory(
 139         "basic", new HttpAuthHandlerBasic::Factory());
 140   if (IsSupportedScheme(supported_schemes, "digest"))
 141     registry_factory->RegisterSchemeFactory(
 142         "digest", new HttpAuthHandlerDigest::Factory());
 143   if (IsSupportedScheme(supported_schemes, "ntlm")) {
 144     HttpAuthHandlerNTLM::Factory* ntlm_factory =
 145         new HttpAuthHandlerNTLM::Factory();
 146     ntlm_factory->set_url_security_manager(security_manager);
 147 #if defined(OS_WIN)
 148     ntlm_factory->set_sspi_library(new SSPILibraryDefault());
 149 #endif
 150     registry_factory->RegisterSchemeFactory("ntlm", ntlm_factory);
 151   }
 152 #if defined(USE_KERBEROS)
 153   if (IsSupportedScheme(supported_schemes, "negotiate")) {
 154     HttpAuthHandlerNegotiate::Factory* negotiate_factory =
 155         new HttpAuthHandlerNegotiate::Factory();
 156 #if defined(OS_POSIX)
 157     negotiate_factory->set_library(
 158         new GSSAPISharedLibrary(gssapi_library_name));
 159 #elif defined(OS_WIN)
 160     negotiate_factory->set_library(new SSPILibraryDefault());
 161 #endif
 162     negotiate_factory->set_url_security_manager(security_manager);
 163     DCHECK(host_resolver || negotiate_disable_cname_lookup);
 164     negotiate_factory->set_host_resolver(host_resolver);
 165     negotiate_factory->set_disable_cname_lookup(negotiate_disable_cname_lookup);
 166     negotiate_factory->set_use_port(negotiate_enable_port);
 167     registry_factory->RegisterSchemeFactory("negotiate", negotiate_factory);
 168   }
 169 #endif  // defined(USE_KERBEROS)
 170
 171   return registry_factory;
 172 }
 173
 174 int HttpAuthHandlerRegistryFactory::CreateAuthHandler(
 175     HttpAuth::ChallengeTokenizer* challenge,
 176     HttpAuth::Target target,
 177     const GURL& origin,
 178     CreateReason reason,
 179     int digest_nonce_count,
 180     const BoundNetLog& net_log,
 181     scoped_ptr<HttpAuthHandler>* handler) {
 182   std::string scheme = challenge->scheme();
 183   if (scheme.empty()) {
 184     handler->reset();
 185     return ERR_INVALID_RESPONSE;
 186   }
 187   std::string lower_scheme = StringToLowerASCII(scheme);
 188   FactoryMap::iterator it = factory_map_.find(lower_scheme);
 189   if (it == factory_map_.end()) {
 190     handler->reset();
 191     return ERR_UNSUPPORTED_AUTH_SCHEME;
 192   }
 193   DCHECK(it->second);
 194   return it->second->CreateAuthHandler(challenge, target, origin, reason,
 195                                        digest_nonce_count, net_log, handler);
 196 }
 197
 198 }  // namespace net