ACE/protocols/ace/INet/URLBase.cpp

   1 #include "ace/INet/URLBase.h"
   2 #include "ace/INet/IOS_util.h"
   3
   4 #if !defined (__ACE_INLINE__)
   5 #include "ace/INet/URLBase.inl"
   6 #endif
   7
   8 #include "ace/INet/String_IOStream.h"
   9
  10 #include "ace/INet/ClientRequestHandler.h"
  11 #include <istream>
  12
  13 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  14
  15 namespace ACE
  16 {
  17   namespace INet
  18   {
  19     URLStream::URLStream (const URLStream& url_stream)
  20       : request_handler_ref_ (url_stream.request_handler_ref_),
  21         request_handler_ (url_stream.request_handler_)
  22       {
  23       }
  24
  25     URLStream::~URLStream ()
  26       {
  27       }
  28
  29     bool URLStream::operator ! ()
  30       {
  31         return this->request_handler_ == 0 || !this->request_handler_->is_response_ok ();
  32       }
  33
  34     URLStream::operator bool ()
  35       {
  36         return this->request_handler_ != 0 && this->request_handler_->is_response_ok ();
  37       }
  38
  39     std::istream& URLStream::operator * ()
  40       {
  41         return this->request_handler_ ?
  42           this->request_handler_->response_stream () :
  43           ACE::IOS::Null::in_stream_;
  44       }
  45
  46     std::istream* URLStream::operator -> ()
  47       {
  48         return this->request_handler_ ?
  49           &this->request_handler_->response_stream () :
  50           &ACE::IOS::Null::in_stream_;
  51       }
  52
  53     URLStream::URLStream (ClientRequestHandler& rh)
  54       : request_handler_ (&rh)
  55       {
  56       }
  57
  58     URLStream::URLStream (ClientRequestHandler* rh)
  59       : request_handler_ref_ (rh),
  60         request_handler_ (rh)
  61       {
  62       }
  63
  64     const ACE_CString URL_Base::empty_;
  65
  66     URL_Base::URL_Base ()
  67       {
  68       }
  69
  70     URL_Base::~URL_Base () {}
  71
  72     bool URL_Base::parse (const ACE_CString& url_string)
  73       {
  74         static const int eof =
  75           std::char_traits<ACE::IOS::CString_OStream::char_type>::eof ();
  76
  77         ACE_CString uri = url_string;
  78         if (this->strip_scheme (uri))
  79           {
  80             ACE::IOS::CString_OStream sos;
  81             ACE::IOS::CString_IStream sis (uri);
  82
  83             int ch;
  84
  85             // parse authority part (if any)
  86             if ((ch = this->parse_authority (sis)) == '/' ||
  87                 !this->has_authority ())      // relative paths allowed if no authority
  88               {
  89                 // parse path part
  90                 sos.put (ch);
  91                 for (ch = sis.get (); ch != '?' && ch != '#' && ch != eof ;ch = sis.get ())
  92                   sos.put (ch);
  93                 this->set_path (sos.str ());
  94                 sos.clear ();
  95               }
  96             else
  97               {
  98                 // empty path
  99                 this->set_path (empty_);
 100               }
 101
 102             if (ch == '?')
 103               {
 104                 // parse query part
 105                 for (ch = sis.get (); ch != '#' && ch != eof ;ch = sis.get ())
 106                   sos.put (ch);
 107                 this->set_query (sos.str ());
 108                 sos.clear ();
 109               }
 110
 111             if (ch == '#')
 112               {
 113                 // get fragment
 114                 sos << sis.rdbuf ();
 115                 this->set_fragment (sos.str ());
 116               }
 117             else if (ch != eof)
 118               {
 119                 // should not happen
 120                 return false;
 121               }
 122
 123             // check for (minimum) correctness
 124             return this->validate ();
 125           }
 126         return false;
 127       }
 128
 129     int URL_Base::parse_authority(std::istream& is)
 130       {
 131         return is.get ();
 132       }
 133
 134     bool URL_Base::has_authority ()
 135       {
 136         return false;
 137       }
 138
 139     bool URL_Base::validate ()
 140       {
 141         return true;
 142       }
 143
 144     URLStream URL_Base::open () const
 145       {
 146         ClientRequestHandler* rh = this->create_default_request_handler ();
 147         if (rh)
 148           {
 149             rh->handle_open_request (*this);
 150             return URLStream (rh);
 151           }
 152         else
 153           return URLStream (0);
 154       }
 155
 156     URLStream URL_Base::open (ClientRequestHandler& rh) const
 157       {
 158         rh.handle_open_request (*this);
 159         return URLStream (rh);
 160       }
 161
 162     URL_Base* URL_Base::create_from_string (const ACE_CString& url_string)
 163       {
 164         ACE_CString::size_type pos = url_string.find (':');
 165         if (pos >0 )
 166           {
 167             Factory* url_factory = 0;
 168             if (factories_->find (url_string.substr (0, pos), url_factory) == 0)
 169               {
 170                 return url_factory->create_from_string (url_string);
 171               }
 172           }
 173
 174         return 0;
 175       }
 176
 177 #if defined (ACE_HAS_WCHAR)
 178     bool URL_Base::parse (const ACE_WString& url_string)
 179       {
 180         return this->parse (ACE_Wide_To_Ascii (url_string.c_str ()).char_rep ());
 181       }
 182
 183     ACE_WString URL_Base::to_wstring () const
 184       {
 185         ACE_Ascii_To_Wide ws(this->to_string().c_str ());
 186         return ws.wchar_rep ();
 187       }
 188
 189     URL_Base* URL_Base::create_from_wstring (const ACE_WString& url_string)
 190       {
 191         return create_from_string (ACE_Wide_To_Ascii (url_string.c_str ()).char_rep ());
 192       }
 193 #endif
 194
 195     bool URL_Base::strip_scheme (ACE_CString& url_string)
 196       {
 197         // since this will be called at a point where the
 198         // actual URL class is already known (and with that
 199         // the protocol prefix) we allow for the fact we
 200         // may get a url passed without the actual prefix
 201
 202         ACE_CString::size_type pos = url_string.find (':');
 203         if (pos > 0 && url_string[pos+1] == '/' && url_string[pos+2] == '/')
 204           {
 205             // in case we find a scheme check for the right protocol
 206             if (this->get_protocol () != url_string.substr (0, pos))
 207               {
 208                 return false;
 209               }
 210             url_string = url_string.substr (pos+3); // skip '<protocol>://'
 211           }
 212         return true;
 213       }
 214
 215     void URL_Base::register_factory (Factory* url_factory)
 216       {
 217         if (factories_ == 0)
 218           {
 219             factories_ = URL_Base::TURLFactorySingleton::instance ();
 220           }
 221         if (url_factory)
 222           factories_->bind (url_factory->protocol (), url_factory);
 223       }
 224
 225     void URL_Base::deregister_factory (Factory* url_factory)
 226       {
 227         if (factories_ && url_factory)
 228           {
 229             factories_->unbind (url_factory->protocol ());
 230           };
 231       }
 232
 233     URL_Base::TURLFactoryMap* URL_Base::factories_ = 0;
 234
 235     URL_Base::Factory::Factory ()
 236       {}
 237
 238     URL_Base::Factory::~Factory ()
 239       {}
 240
 241     URL_INetBase::URL_INetBase (u_short port)
 242       : URL_Base (), port_ (port)
 243       {
 244       }
 245
 246     URL_INetBase::~URL_INetBase () {}
 247
 248     int URL_INetBase::parse_authority (std::istream& is)
 249       {
 250         ACE::IOS::CString_OStream sos;
 251         return this->parse_authority_i (is, sos, 0);
 252       }
 253
 254     int URL_INetBase::parse_authority_i (std::istream& is,
 255                                          std::ostream& os,
 256                                          int lastch)
 257       {
 258         static const int eof =
 259           std::char_traits<ACE::IOS::CString_OStream::char_type>::eof ();
 260
 261         ACE::IOS::CString_OStream& sos =
 262             dynamic_cast<ACE::IOS::CString_OStream&> (os);
 263
 264         int ch = lastch;
 265         if (ch == 0)
 266           {
 267             // parse host part
 268             for (ch = is.get ();
 269 #if defined (ACE_HAS_IPV6)
 270                  ch != '[' && ch != '/' && ch != ':' && ch != '@' && ch != '?' && ch != '#' && ch != eof ;
 271 #else
 272                  ch != '/' && ch != ':' && ch != '@' && ch != '?' && ch != '#' && ch != eof ;
 273 #endif
 274                  ch = is.get ())
 275               sos.put (ch);
 276           }
 277
 278 #if defined (ACE_HAS_IPV6)
 279         if (ch == '[')
 280           {
 281             sos.clear ();
 282             for (ch = is.get (); ch != ']' && ch != eof ;ch = is.get ())
 283               sos.put (ch);
 284             if (ch != eof)
 285               ch = is.get (); // skip ']'
 286             if (ch != '/' && ch != ':' && ch != '?' && ch != '#' && ch != eof)
 287               {
 288                 this->set_host (empty_); // invalid URL, clear host field
 289                 ch = eof; // stop parsing
 290               }
 291             else
 292               {
 293                 this->set_host (sos.str ());
 294               }
 295           }
 296         else
 297           {
 298 #endif
 299             this->set_host (sos.str ());
 300 #if defined (ACE_HAS_IPV6)
 301           }
 302 #endif
 303         sos.clear ();
 304
 305         if (ch == ':')
 306           {
 307             u_short port = 0;
 308             is >> port; // should stop at '/' or '?' or '#' or eof
 309             ch = is.get ();
 310             if (ch == '/' || ch == '?' || ch == '#' || ch == eof)
 311               this->set_port (port);
 312             else
 313               this->set_port (0);
 314           }
 315         else
 316           {
 317             this->set_port (this->default_port ());
 318           }
 319
 320         return ch;
 321       }
 322
 323     bool URL_INetBase::has_authority ()
 324       {
 325         return true;
 326       }
 327
 328     bool URL_INetBase::validate ()
 329       {
 330         return !this->host_.empty () && this->port_>0;
 331       }
 332
 333     ACE_CString URL_INetBase::get_authority () const
 334       {
 335         ACE::IOS::CString_OStream sos;
 336         sos << this->get_host().c_str ();
 337         if (this->get_port () != this->default_port ())
 338           sos << ':' << this->get_port ();
 339         return sos.str ();
 340       }
 341
 342     URL_INetAuthBase::authenticator_map URL_INetAuthBase::authenticators_;
 343
 344     URL_INetAuthBase::URL_INetAuthBase (u_short port)
 345       : URL_INetBase (port)
 346       {
 347       }
 348
 349     URL_INetAuthBase::~URL_INetAuthBase () {}
 350
 351     ACE_CString URL_INetAuthBase::get_authority () const
 352       {
 353         ACE::IOS::CString_OStream sos;
 354         if (!this->get_user_info ().empty ())
 355           sos << this->get_user_info ().c_str () << "@";
 356         sos << this->get_host().c_str ();
 357         if (this->get_port () != this->default_port ())
 358           sos << ':' << this->get_port ();
 359         return sos.str ();
 360       }
 361
 362     int URL_INetAuthBase::parse_authority (std::istream& is)
 363       {
 364         static const int eof =
 365           std::char_traits<ACE::IOS::CString_OStream::char_type>::eof ();
 366
 367         ACE::IOS::CString_OStream sos;
 368
 369         int ch;
 370         // parse userinfo (if any)
 371         for (ch = is.get ();
 372 #if defined (ACE_HAS_IPV6)
 373              ch != '[' && ch != '/' && ch != ':' && ch != '@' && ch != '?' && ch != '#' && ch != eof ;
 374 #else
 375              ch != '/' && ch != ':' && ch != '@' && ch != '?' && ch != '#' && ch != eof ;
 376 #endif
 377              ch = is.get ())
 378           sos.put (ch);
 379
 380         if (ch == '@')
 381           {
 382             this->set_user_info (sos.str ());
 383             sos.clear ();
 384             ch = URL_INetBase::parse_authority_i (is, sos, 0);
 385           }
 386         else
 387           {
 388             ch = URL_INetBase::parse_authority_i (is, sos, ch);
 389           }
 390
 391         return ch;
 392       }
 393
 394     bool URL_INetAuthBase::add_authenticator (const ACE_CString& auth_id,
 395                                              AuthenticatorBase* authenticator)
 396       {
 397         if (URL_INetAuthBase::authenticators_.find (auth_id) == -1)
 398           {
 399             return URL_INetAuthBase::authenticators_.bind (auth_id,
 400                                                            authenticator_ptr (authenticator)) == 0;
 401           }
 402         return false;
 403       }
 404
 405     bool URL_INetAuthBase::has_authenticator (const ACE_CString& auth_id)
 406       {
 407         return (URL_INetAuthBase::authenticators_.find (auth_id) == 0);
 408       }
 409
 410     AuthenticatorBase* URL_INetAuthBase::remove_authenticator (const ACE_CString& auth_id)
 411       {
 412         authenticator_ptr auth;
 413         if (URL_INetAuthBase::authenticators_.unbind (auth_id, auth) == 0)
 414           {
 415             auth.release ();
 416           }
 417         return 0;
 418       }
 419
 420     bool URL_INetAuthBase::authenticate (AuthenticationBase& authentication)
 421       {
 422         ACE_GUARD_RETURN (ACE_SYNCH::RECURSIVE_MUTEX,
 423                           _guard,
 424                           URL_INetAuthBase::authenticators_.mutex (),
 425                           false);
 426
 427         authenticator_map::iterator it = URL_INetAuthBase::authenticators_.begin ();
 428         for (; it != URL_INetAuthBase::authenticators_.end ();
 429              ++it)
 430           {
 431             authenticator_ptr auth_ptr = (*it).int_id_;
 432
 433             // release lock before calling user code
 434             if (URL_INetAuthBase::authenticators_.mutex ().release () != 0)
 435               return false;
 436
 437             if (auth_ptr->authenticate (authentication))
 438               return true;
 439
 440             // re-acquire lock
 441             if (URL_INetAuthBase::authenticators_.mutex ().acquire () != 0)
 442               return false;
 443           }
 444
 445         return false;
 446       }
 447   }
 448 }
 449
 450 ACE_END_VERSIONED_NAMESPACE_DECL