ACE/protocols/ace/INet/HTTP_ClientRequestHandler.h

   1 /**
   2  * @file HTTP_ClientRequestHandler.h
   3  *
   4  * @author Martin Corino <mcorino@remedy.nl>
   5  */
   6
   7 #ifndef ACE_HTTP_CLIENT_REQUEST_HANDLER_H
   8 #define ACE_HTTP_CLIENT_REQUEST_HANDLER_H
   9
  10 #include /**/ "ace/pre.h"
  11
  12 #include /**/ "ace/config-all.h"
  13
  14 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  15 # pragma once
  16 #endif /* ACE_LACKS_PRAGMA_ONCE */
  17
  18 #include "ace/Synch_Traits.h"
  19 #include "ace/Singleton.h"
  20 #include "ace/Thread_Mutex.h"
  21 #include "ace/INet/INet_Export.h"
  22 #include "ace/INet/IOS_util.h"
  23 #include "ace/INet/StreamInterceptor.h"
  24 #include "ace/INet/ClientRequestHandler.h"
  25 #include "ace/INet/HTTP_Request.h"
  26 #include "ace/INet/HTTP_Response.h"
  27 #include "ace/INet/HTTP_URL.h"
  28 #include "ace/INet/HTTP_Session.h"
  29
  30 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  31
  32 namespace ACE
  33   {
  34     namespace HTTP
  35       {
  36         /**
  37         * @class ACE_HTTP_SessionHolder
  38         *
  39         * @brief Abstract base class for HTTP session objects.
  40         *
  41         */
  42         class ACE_INET_Export SessionHolder
  43           : public ACE::INet::ConnectionHolder
  44           {
  45             protected:
  46               SessionHolder ();
  47               virtual ~SessionHolder();
  48
  49               virtual SessionBase& session () = 0;
  50
  51             public:
  52               SessionBase& operator *();
  53               SessionBase* operator ->();
  54           };
  55
  56         /**
  57         * @class ACE_HTTP_SessionFactory
  58         *
  59         * @brief Abstract base class for HTTP session factories.
  60         *
  61         */
  62         class ACE_INET_Export SessionFactory
  63           : public ACE::INet::ConnectionFactory
  64           {
  65             protected:
  66               SessionFactory () {}
  67               virtual ~SessionFactory () {}
  68           };
  69
  70         /**
  71         * @class ACE_HTTP_SessionFactory_Impl
  72         *
  73         * @brief Implementation of HTTP session factory.
  74         *
  75         */
  76         class ACE_INET_Export SessionFactory_Impl
  77           : public SessionFactory
  78           {
  79             private:
  80               SessionFactory_Impl ();
  81               virtual ~SessionFactory_Impl ();
  82
  83               friend class ACE_Singleton<SessionFactory_Impl, ACE_SYNCH::NULL_MUTEX>;
  84
  85               static SessionFactory_Impl& factory_;
  86
  87               class SessionHolder_Impl : public SessionHolder
  88                 {
  89                   public:
  90                     SessionHolder_Impl ();
  91                     virtual ~SessionHolder_Impl();
  92
  93                   protected:
  94                     virtual SessionBase& session ();
  95
  96                   private:
  97                     Session_T<ACE_SYNCH> session_;
  98                 };
  99
 100             public:
 101               virtual ACE::INet::ConnectionHolder* create_connection (
 102                   const ACE::INet::ConnectionKey& key) const;
 103           };
 104
 105         /**
 106         * @class ACE_HTTP_SessionFactoryRegistry
 107         *
 108         * @brief Implements registry of HTTP session factories.
 109         *
 110         */
 111         class ACE_INET_Export SessionFactoryRegistry
 112           {
 113             private:
 114               SessionFactoryRegistry ();
 115               ~SessionFactoryRegistry ();
 116
 117               friend class ACE_Singleton<SessionFactoryRegistry, ACE_SYNCH::MUTEX>;
 118
 119             public:
 120               void register_session_factory (const ACE_CString& scheme,
 121                                              SessionFactory* factory);
 122
 123               SessionFactory* find_session_factory (const ACE_CString& scheme);
 124
 125               static SessionFactoryRegistry& instance ();
 126
 127             private:
 128               typedef ACE_Map_Manager<ACE_CString,
 129                                       SessionFactory*,
 130                                       ACE_SYNCH::MUTEX> TSessionFactoryMap;
 131
 132               TSessionFactoryMap factory_map_;
 133           };
 134
 135         /**
 136         * @class ACE_HTTP_ClientRequestHandler
 137         *
 138         * @brief This class implements clientside request handling
 139         *   for HTTP(S) URLs.
 140         *
 141         * The class supports the HTTP protocol as specified in RFC 2616.
 142         */
 143         class ACE_INET_Export ClientRequestHandler
 144           : public ACE::INet::ClientINetRequestHandler,
 145             public ACE::IOS::StreamInterceptor
 146           {
 147             public:
 148               ClientRequestHandler ();
 149               virtual ~ClientRequestHandler ();
 150
 151               virtual Request& request ();
 152
 153               virtual const Request& request () const;
 154
 155               virtual Response& response ();
 156
 157               virtual const Response& response () const;
 158
 159               std::ostream& request_stream ();
 160
 161               virtual std::istream& response_stream ();
 162
 163               virtual bool is_response_ok () const;
 164
 165               virtual std::istream& handle_open_request (const ACE::INet::URL_Base& url);
 166
 167               virtual std::istream& handle_get_request (const URL& url);
 168 /*
 169               virtual std::istream& handle_post_request (const URL& url,
 170                                                          const PostData& post_data);
 171
 172               virtual std::istream& handle_put_request (const URL& url,
 173                                                         std::istream* put_data = 0);
 174 */
 175
 176               class ACE_INET_Export HttpConnectionKey
 177                 : public INetConnectionKey
 178                 {
 179                   public:
 180                     HttpConnectionKey (const ACE_CString& host,
 181                                        u_short port);
 182                     HttpConnectionKey (const ACE_CString& proxy_host,
 183                                        u_short proxy_port,
 184                                        const ACE_CString& target_host,
 185                                        u_short target_port);
 186                     virtual ~HttpConnectionKey();
 187
 188                     virtual u_long hash () const;
 189
 190                     virtual ACE::INet::ConnectionKey* duplicate () const;
 191
 192                     bool is_proxy_connection () const;
 193
 194                     const ACE_CString& proxy_target_host () const;
 195
 196                     u_short proxy_target_port () const;
 197
 198                   protected:
 199                     virtual bool equal (const ACE::INet::ConnectionKey& key) const;
 200
 201                   private:
 202                     bool proxy_connection_;
 203                     ACE_CString proxy_target_host_;
 204                     u_short proxy_target_port_;
 205                 };
 206
 207             protected:
 208               virtual void on_eof ();
 209
 210               SessionHolder& session ();
 211
 212               void session (SessionHolder* session);
 213
 214               virtual bool initialize_connection (const ACE_CString& scheme,
 215                                                   const ACE_CString& host,
 216                                                   u_short port,
 217                                                   bool proxy_conn = false,
 218                                                   const ACE_CString& proxy_host = Request::EMPTY,
 219                                                   u_short proxy_port = 0);
 220
 221               virtual void initialize_request (const URL& url, Request& request);
 222
 223               virtual void handle_request_error (const URL& url);
 224
 225               virtual void handle_connection_error (const URL& url);
 226
 227               void release_connection ();
 228
 229               void close_connection ();
 230
 231             private:
 232               Request request_;
 233               Response response_;
 234               SessionHolder* session_;
 235           };
 236       }
 237   }
 238
 239 ACE_END_VERSIONED_NAMESPACE_DECL
 240
 241 #if defined (__ACE_INLINE__)
 242 #include "ace/INet/HTTP_ClientRequestHandler.inl"
 243 #endif
 244
 245 #include /**/ "ace/post.h"
 246 #endif /* ACE_INET_CLIENT_REQUEST_HANDLER_H */