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         return ACE_Ascii_To_Wide (this->to_string().c_str ()).wchar_rep ();
 186       }
 187
 188     URL_Base* URL_Base::create_from_wstring (const ACE_WString& url_string)
 189       {
 190         return create_from_string (ACE_Wide_To_Ascii (url_string.c_str ()).char_rep ());
 191       }
 192 #endif
 193
 194     bool URL_Base::strip_scheme (ACE_CString& url_string)
 195       {
 196         // since this will be called at a point where the
 197         // actual URL class is already known (and with that
 198         // the protocol prefix) we allow for the fact we
 199         // may get a url passed without the actual prefix
 200
 201         ACE_CString::size_type pos = url_string.find (':');
 202         if (pos > 0 && url_string[pos+1] == '/' && url_string[pos+2] == '/')
 203           {
 204             // in case we find a scheme check for the right protocol
 205             if (this->get_protocol () != url_string.substr (0, pos))
 206               {
 207                 return false;
 208               }
 209             url_string = url_string.substr (pos+3); // skip '<protocol>://'
 210           }
 211         return true;
 212       }
 213
 214     void URL_Base::register_factory (Factory* url_factory)
 215       {
 216         if (factories_ == 0)
 217           {
 218             factories_ = URL_Base::TURLFactorySingleton::instance ();
 219           }
 220         if (url_factory)
 221           factories_->bind (url_factory->protocol (), url_factory);
 222       }
 223
 224     void URL_Base::deregister_factory (Factory* url_factory)
 225       {
 226         if (factories_ && url_factory)
 227           {
 228             factories_->unbind (url_factory->protocol ());
 229           };
 230       }
 231
 232     URL_Base::TURLFactoryMap* URL_Base::factories_ = 0;
 233
 234     URL_Base::Factory::Factory ()
 235       {}
 236
 237     URL_Base::Factory::~Factory ()
 238       {}
 239
 240     URL_INetBase::URL_INetBase (u_short port)
 241       : URL_Base (), port_ (port)
 242       {
 243       }
 244
 245     URL_INetBase::~URL_INetBase () {}
 246
 247     int URL_INetBase::parse_authority (std::istream& is)
 248       {
 249         ACE::IOS::CString_OStream sos;
 250         return this->parse_authority_i (is, sos, 0);
 251       }
 252
 253     int URL_INetBase::parse_authority_i (std::istream& is,
 254                                          std::ostream& os,
 255                                          int lastch)
 256       {
 257         static const int eof =
 258           std::char_traits<ACE::IOS::CString_OStream::char_type>::eof ();
 259
 260         ACE::IOS::CString_OStream& sos =
 261             dynamic_cast<ACE::IOS::CString_OStream&> (os);
 262
 263         int ch = lastch;
 264         if (ch == 0)
 265           {
 266             // parse host part
 267             for (ch = is.get ();
 268 #if defined (ACE_HAS_IPV6)
 269                  ch != '[' && ch != '/' && ch != ':' && ch != '@' && ch != '?' && ch != '#' && ch != eof ;
 270 #else
 271                  ch != '/' && ch != ':' && ch != '@' && ch != '?' && ch != '#' && ch != eof ;
 272 #endif
 273                  ch = is.get ())
 274               sos.put (ch);
 275           }
 276
 277 #if defined (ACE_HAS_IPV6)
 278         if (ch == '[')
 279           {
 280             sos.clear ();
 281             for (ch = is.get (); ch != ']' && ch != eof ;ch = is.get ())
 282               sos.put (ch);
 283             if (ch != eof)
 284               ch = is.get (); // skip ']'
 285             if (ch != '/' && ch != ':' && ch != '?' && ch != '#' && ch != eof)
 286               {
 287                 this->set_host (empty_); // invalid URL, clear host field
 288                 ch = eof; // stop parsing
 289               }
 290             else
 291               {
 292                 this->set_host (sos.str ());
 293               }
 294           }
 295         else
 296           {
 297 #endif
 298             this->set_host (sos.str ());
 299 #if defined (ACE_HAS_IPV6)
 300           }
 301 #endif
 302         sos.clear ();
 303
 304         if (ch == ':')
 305           {
 306             u_short port = 0;
 307             is >> port; // should stop at '/' or '?' or '#' or eof
 308             ch = is.get ();
 309             if (ch == '/' || ch == '?' || ch == '#' || ch == eof)
 310               this->set_port (port);
 311             else
 312               this->set_port (0);
 313           }
 314         else
 315           {
 316             this->set_port (this->default_port ());
 317           }
 318
 319         return ch;
 320       }
 321
 322     bool URL_INetBase::has_authority ()
 323       {
 324         return true;
 325       }
 326
 327     bool URL_INetBase::validate ()
 328       {
 329         return !this->host_.empty () && this->port_>0;
 330       }
 331
 332     ACE_CString URL_INetBase::get_authority () const
 333       {
 334         ACE::IOS::CString_OStream sos;
 335         sos << this->get_host().c_str ();
 336         if (this->get_port () != this->default_port ())
 337           sos << ':' << this->get_port ();
 338         return sos.str ();
 339       }
 340
 341     URL_INetAuthBase::authenticator_map URL_INetAuthBase::authenticators_;
 342
 343     URL_INetAuthBase::URL_INetAuthBase (u_short port)
 344       : URL_INetBase (port)
 345       {
 346       }
 347
 348     URL_INetAuthBase::~URL_INetAuthBase () {}
 349
 350     ACE_CString URL_INetAuthBase::get_authority () const
 351       {
 352         ACE::IOS::CString_OStream sos;
 353         if (!this->get_user_info ().empty ())
 354           sos << this->get_user_info ().c_str () << "@";
 355         sos << this->get_host().c_str ();
 356         if (this->get_port () != this->default_port ())
 357           sos << ':' << this->get_port ();
 358         return sos.str ();
 359       }
 360
 361     int URL_INetAuthBase::parse_authority (std::istream& is)
 362       {
 363         static const int eof =
 364           std::char_traits<ACE::IOS::CString_OStream::char_type>::eof ();
 365
 366         ACE::IOS::CString_OStream sos;
 367
 368         int ch;
 369         // parse userinfo (if any)
 370         for (ch = is.get ();
 371 #if defined (ACE_HAS_IPV6)
 372              ch != '[' && ch != '/' && ch != ':' && ch != '@' && ch != '?' && ch != '#' && ch != eof ;
 373 #else
 374              ch != '/' && ch != ':' && ch != '@' && ch != '?' && ch != '#' && ch != eof ;
 375 #endif
 376              ch = is.get ())
 377           sos.put (ch);
 378
 379         if (ch == '@')
 380           {
 381             this->set_user_info (sos.str ());
 382             sos.clear ();
 383             ch = URL_INetBase::parse_authority_i (is, sos, 0);
 384           }
 385         else
 386           {
 387             ch = URL_INetBase::parse_authority_i (is, sos, ch);
 388           }
 389
 390         return ch;
 391       }
 392
 393     bool URL_INetAuthBase::add_authenticator (const ACE_CString& auth_id,
 394                                              AuthenticatorBase* authenticator)
 395       {
 396         if (URL_INetAuthBase::authenticators_.find (auth_id) == -1)
 397           {
 398             return URL_INetAuthBase::authenticators_.bind (auth_id,
 399                                                            authenticator_ptr (authenticator)) == 0;
 400           }
 401         return false;
 402       }
 403
 404     bool URL_INetAuthBase::has_authenticator (const ACE_CString& auth_id)
 405       {
 406         return (URL_INetAuthBase::authenticators_.find (auth_id) == 0);
 407       }
 408
 409     AuthenticatorBase* URL_INetAuthBase::remove_authenticator (const ACE_CString& auth_id)
 410       {
 411         authenticator_ptr auth;
 412         if (URL_INetAuthBase::authenticators_.unbind (auth_id, auth) == 0)
 413           {
 414             auth.release ();
 415           }
 416         return 0;
 417       }
 418
 419     bool URL_INetAuthBase::authenticate (AuthenticationBase& authentication)
 420       {
 421         ACE_GUARD_RETURN (ACE_SYNCH::RECURSIVE_MUTEX,
 422                           _guard,
 423                           URL_INetAuthBase::authenticators_.mutex (),
 424                           false);
 425
 426         authenticator_map::iterator it = URL_INetAuthBase::authenticators_.begin ();
 427         for (; it != URL_INetAuthBase::authenticators_.end ();
 428              ++it)
 429           {
 430             authenticator_ptr auth_ptr = (*it).int_id_;
 431
 432             // release lock before calling user code
 433             if (URL_INetAuthBase::authenticators_.mutex ().release () != 0)
 434               return false;
 435
 436             if (auth_ptr->authenticate (authentication))
 437               return true;
 438
 439             // re-acquire lock
 440             if (URL_INetAuthBase::authenticators_.mutex ().acquire () != 0)
 441               return false;
 442           }
 443
 444         return false;
 445       }
 446   }
 447 }
 448
 449 ACE_END_VERSIONED_NAMESPACE_DECL