ACE/protocols/ace/INet/HTTP_ClientRequestHandler.cpp

   1 #include "ace/INet/HTTP_ClientRequestHandler.h"
   2
   3 #if !defined (__ACE_INLINE__)
   4 #include "ace/INet/HTTP_ClientRequestHandler.inl"
   5 #endif
   6
   7 #include "ace/INet/INet_Log.h"
   8 #include <memory>
   9 #include "ace/Functor_String.h"
  10
  11 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  12
  13 namespace ACE
  14 {
  15   namespace HTTP
  16   {
  17     SessionFactoryRegistry::SessionFactoryRegistry ()
  18       {
  19       }
  20
  21     SessionFactoryRegistry::~SessionFactoryRegistry ()
  22       {
  23       }
  24
  25     void SessionFactoryRegistry::register_session_factory (
  26         const ACE_CString& scheme,
  27         SessionFactory* factory)
  28       {
  29         if (factory == 0)
  30           this->factory_map_.unbind (scheme);
  31         else
  32           this->factory_map_.rebind (scheme, factory);
  33       }
  34
  35     SessionFactory*
  36     SessionFactoryRegistry::find_session_factory (const ACE_CString& scheme)
  37       {
  38         SessionFactory* factory = 0;
  39         this->factory_map_.find (scheme, factory);
  40         return factory;
  41       }
  42
  43     SessionFactoryRegistry& SessionFactoryRegistry::instance ()
  44       {
  45         return *ACE_Singleton<SessionFactoryRegistry, ACE_SYNCH::MUTEX>::instance ();
  46       }
  47
  48     SessionHolder::SessionHolder ()
  49       {
  50       }
  51
  52     SessionHolder::~SessionHolder()
  53       {
  54       }
  55
  56     SessionFactory_Impl::SessionHolder_Impl::SessionHolder_Impl ()
  57       : session_ (true)
  58       {
  59       }
  60
  61     SessionFactory_Impl::SessionHolder_Impl::~SessionHolder_Impl()
  62       {
  63       }
  64
  65     SessionBase& SessionFactory_Impl::SessionHolder_Impl::session ()
  66       {
  67         return this->session_;
  68       }
  69
  70     SessionFactory_Impl& SessionFactory_Impl::factory_ =
  71         *ACE_Singleton<SessionFactory_Impl,ACE_SYNCH::NULL_MUTEX>::instance ();
  72
  73     SessionFactory_Impl::SessionFactory_Impl ()
  74       {
  75         INET_DEBUG (6, (LM_INFO, DLINFO
  76                                  ACE_TEXT ("HTTP_SessionFactory_Impl::ctor - ")
  77                                  ACE_TEXT ("registering session factory for scheme [%C]\n"),
  78                                  URL::protocol ().c_str ()));
  79         SessionFactoryRegistry::instance ().register_session_factory (URL::protocol (), this);
  80       }
  81
  82     SessionFactory_Impl::~SessionFactory_Impl ()
  83       {
  84       }
  85
  86     ACE::INet::ConnectionHolder*
  87     SessionFactory_Impl::create_connection (
  88         const ACE::INet::ConnectionKey& key) const
  89       {
  90         INET_TRACE ("HTTP_SessionFactory_Impl::create_connection");
  91
  92         const ClientRequestHandler::HttpConnectionKey& ikey =
  93             dynamic_cast<const ClientRequestHandler::HttpConnectionKey&> (key);
  94
  95         SessionHolder_Impl* session_holder = 0;
  96         ACE_NEW_RETURN (session_holder,
  97                         SessionHolder_Impl (),
  98                         0);
  99         std::unique_ptr<SessionHolder_Impl> session_safe_ref (session_holder);
 100
 101         (*session_holder)->set_host (ikey.host (), ikey.port ());
 102         if (ikey.is_proxy_connection ())
 103           {
 104             (*session_holder)->set_proxy_target (ikey.proxy_target_host (),
 105                                                  ikey.proxy_target_port ());
 106           }
 107
 108         if ((*session_holder)->connect (true))
 109           {
 110             return session_safe_ref.release ();
 111           }
 112
 113         return 0;
 114       }
 115
 116     ClientRequestHandler::HttpConnectionKey::HttpConnectionKey (
 117         const ACE_CString& host,
 118         u_short port)
 119       : INetConnectionKey (host, port),
 120         proxy_connection_ (false),
 121         proxy_target_port_ (0)
 122       {
 123       }
 124
 125     ClientRequestHandler::HttpConnectionKey::HttpConnectionKey (
 126         const ACE_CString& proxy_host,
 127         u_short proxy_port,
 128         const ACE_CString& host,
 129         u_short port)
 130       : INetConnectionKey (proxy_host, proxy_port),
 131         proxy_connection_ (true),
 132         proxy_target_host_ (host),
 133         proxy_target_port_ (port)
 134       {
 135       }
 136
 137     ClientRequestHandler::HttpConnectionKey::~HttpConnectionKey()
 138       {
 139       }
 140
 141     u_long ClientRequestHandler::HttpConnectionKey::hash () const
 142       {
 143         if (this->proxy_connection_)
 144           return ACE_Hash<ACE_CString>()(this->proxy_target_host_) +
 145                 this->proxy_target_port_ +
 146                 (this->proxy_connection_ ? 1 : 0);
 147         else
 148           return INetConnectionKey::hash () +
 149                 (this->proxy_connection_ ? 1 : 0);
 150       }
 151
 152     ACE::INet::ConnectionKey* ClientRequestHandler::HttpConnectionKey::duplicate () const
 153       {
 154         ACE::INet::ConnectionKey* k = 0;
 155         if (this->proxy_connection_)
 156           {
 157             ACE_NEW_RETURN (k,
 158                             HttpConnectionKey (this->host (), this->port (),
 159                                                this->proxy_target_host_,
 160                                                this->proxy_target_port_),
 161                             0);
 162           }
 163         else
 164           {
 165             ACE_NEW_RETURN (k,
 166                             HttpConnectionKey (this->host (), this->port ()),
 167                             0);
 168           }
 169         return k;
 170       }
 171
 172     bool ClientRequestHandler::HttpConnectionKey::equal (const ACE::INet::ConnectionKey& key) const
 173       {
 174         try {
 175           const HttpConnectionKey& http_key = dynamic_cast<const HttpConnectionKey&> (key);
 176           return (INetConnectionKey::equal (key) &&
 177                     this->proxy_connection_ == http_key.is_proxy_connection () &&
 178                     (!this->proxy_connection_ ||
 179                      (this->proxy_target_host_ == http_key.proxy_target_host () &&
 180                       this->proxy_target_port_ == http_key.proxy_target_port ())));
 181         }
 182         catch (...) {
 183           return false;
 184         }
 185       }
 186
 187     ClientRequestHandler::ClientRequestHandler ()
 188       : request_ (Request::HTTP_1_0),
 189         session_ (0)
 190       {
 191       }
 192
 193     ClientRequestHandler::~ClientRequestHandler ()
 194       {
 195         this->release_connection ();
 196       }
 197
 198     bool ClientRequestHandler::is_response_ok () const
 199       {
 200         return this->response_.get_status ().is_ok () &&
 201                 !const_cast<ClientRequestHandler*> (this)->response_stream ().bad ();
 202       }
 203
 204     std::istream& ClientRequestHandler::handle_open_request (
 205         const ACE::INet::URL_Base& url)
 206       {
 207         const URL& http_url = dynamic_cast<const URL&> (url);
 208         return this->handle_get_request (http_url);
 209       }
 210
 211     std::istream& ClientRequestHandler::handle_get_request (
 212         const URL& http_url)
 213       {
 214         bool connected = false;
 215         if (http_url.has_proxy ())
 216           connected = this->initialize_connection (http_url.get_scheme (),
 217                                                    http_url.get_host(),
 218                                                    http_url.get_port (),
 219                                                    true,
 220                                                    http_url.get_proxy_host(),
 221                                                    http_url.get_proxy_port ());
 222         else
 223           connected = this->initialize_connection (http_url.get_scheme (),
 224                                                    http_url.get_host(),
 225                                                    http_url.get_port ());
 226
 227         if (connected)
 228           {
 229             this->request_.reset (Request::HTTP_GET,
 230                                   http_url.get_request_uri (),
 231                                   this->request_.get_version ());
 232
 233             this->response_.reset ();
 234
 235             this->initialize_request (http_url, this->request_);
 236
 237             if (!this->session ()->send_request (this->request_) ||
 238                 !this->session ()->receive_response (this->response_))
 239               {
 240                 this->close_connection ();
 241
 242                 this->handle_request_error(http_url);
 243               }
 244           }
 245         else
 246           {
 247             this->handle_connection_error (http_url);
 248           }
 249
 250         return this->response_stream ();
 251       }
 252
 253     void ClientRequestHandler::on_eof ()
 254       {
 255         this->release_connection ();
 256       }
 257
 258     bool ClientRequestHandler::initialize_connection (const ACE_CString& scheme,
 259                                                       const ACE_CString& host,
 260                                                       u_short port,
 261                                                       bool proxy_conn,
 262                                                       const ACE_CString& proxy_host,
 263                                                       u_short proxy_port)
 264       {
 265         SessionFactory* session_factory =
 266           SessionFactoryRegistry::instance ().find_session_factory (scheme);
 267
 268         if (session_factory == 0)
 269           {
 270             INET_ERROR (1, (LM_ERROR, DLINFO
 271                             ACE_TEXT ("ClientRequestHandler::initialize_connection - ")
 272                             ACE_TEXT ("unable to find session factory for scheme [%C]\n"),
 273                             scheme.c_str ()));
 274             return false;
 275           }
 276
 277         ACE::INet::ConnectionHolder* pch = 0;
 278         if (proxy_conn)
 279           {
 280             if (!this->connection_cache ().claim_connection (HttpConnectionKey (proxy_host,
 281                                                                                 proxy_port,
 282                                                                                 host,
 283                                                                                 port),
 284                                                             pch,
 285                                                             *session_factory))
 286               return false;
 287           }
 288         else
 289           {
 290             if (!this->connection_cache ().claim_connection (HttpConnectionKey (host,
 291                                                                                 port),
 292                                                             pch,
 293                                                             *session_factory))
 294               return false;
 295           }
 296
 297         this->session (dynamic_cast<SessionHolder*> (pch));
 298         return true;
 299       }
 300
 301     void ClientRequestHandler::initialize_request (const URL& /*url*/, Request& /*request*/)
 302       {
 303       }
 304
 305     void ClientRequestHandler::handle_request_error (const URL& /*url*/)
 306       {
 307       }
 308
 309     void ClientRequestHandler::handle_connection_error (const URL& /*url*/)
 310       {
 311       }
 312
 313     void ClientRequestHandler::release_connection ()
 314       {
 315         if (this->session_)
 316           {
 317             if (this->session ()->is_proxy_connection ())
 318               {
 319                 this->connection_cache ().release_connection (
 320                     HttpConnectionKey (this->session ()->get_host (),
 321                                        this->session ()->get_port (),
 322                                        this->session ()->get_proxy_target_host (),
 323                                        this->session ()->get_proxy_target_port ()),
 324                     this->session_);
 325               }
 326             else
 327               {
 328                 this->connection_cache ().release_connection (
 329                     HttpConnectionKey (this->session ()->get_host (),
 330                                        this->session ()->get_port ()),
 331                     this->session_);
 332               }
 333             this->session_ = 0;
 334           }
 335       }
 336
 337     void ClientRequestHandler::close_connection ()
 338       {
 339         if (this->session_)
 340           {
 341             if (this->session ()->is_proxy_connection ())
 342               {
 343                 this->connection_cache ().release_connection (
 344                     HttpConnectionKey (this->session ()->get_host (),
 345                                        this->session ()->get_port (),
 346                                        this->session ()->get_proxy_target_host (),
 347                                        this->session ()->get_proxy_target_port ()),
 348                     this->session_);
 349               }
 350             else
 351               {
 352                 this->connection_cache ().release_connection (
 353                     HttpConnectionKey (this->session ()->get_host (),
 354                                        this->session ()->get_port ()),
 355                     this->session_);
 356               }
 357             this->session_ = 0;
 358           }
 359       }
 360
 361   }
 362 }
 363
 364 ACE_END_VERSIONED_NAMESPACE_DECL