src/common/url.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        url.cpp
   3 // Purpose:     URL parser
   4 // Author:      Guilhem Lavaux
   5 // Modified by:
   6 // Created:     20/07/1997
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1997, 1998 Guilhem Lavaux
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  13 #pragma implementation "url.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20 #pragma hdrstop
  21 #endif
  22
  23 #if wxUSE_URL
  24
  25 #include "wx/string.h"
  26 #include "wx/list.h"
  27 #include "wx/utils.h"
  28 #include "wx/module.h"
  29 #include "wx/url.h"
  30
  31 #include <string.h>
  32 #include <ctype.h>
  33
  34 IMPLEMENT_CLASS(wxProtoInfo, wxObject)
  35 IMPLEMENT_CLASS(wxURL, wxURI)
  36
  37 // Protocols list
  38 wxProtoInfo *wxURL::ms_protocols = NULL;
  39
  40 // Enforce linking of protocol classes:
  41 USE_PROTOCOL(wxFileProto)
  42
  43 #if wxUSE_SOCKETS
  44 USE_PROTOCOL(wxHTTP)
  45 USE_PROTOCOL(wxFTP)
  46
  47     wxHTTP *wxURL::ms_proxyDefault = NULL;
  48     bool wxURL::ms_useDefaultProxy = false;
  49 #endif
  50
  51 // --------------------------------------------------------------
  52 //
  53 //                          wxURL
  54 //
  55 // --------------------------------------------------------------
  56
  57 // --------------------------------------------------------------
  58 // Construction
  59 // --------------------------------------------------------------
  60
  61 wxURL::wxURL(const wxString& url) : wxURI(url)
  62 {
  63     Init(url);
  64     ParseURL();
  65 }
  66
  67 wxURL::wxURL(const wxURI& url) : wxURI(url)
  68 {
  69     Init(url.BuildURI());
  70     ParseURL();
  71 }
  72
  73 void wxURL::Init(const wxString& url)
  74 {
  75     m_protocol = NULL;
  76     m_error = wxURL_NOERR;
  77     m_url = url;
  78 #if wxUSE_URL_NATIVE
  79     m_nativeImp = CreateNativeImpObject();
  80 #endif
  81
  82 #if wxUSE_SOCKETS
  83     if ( ms_useDefaultProxy && !ms_proxyDefault )
  84     {
  85         SetDefaultProxy( wxGetenv(wxT("HTTP_PROXY")) );
  86
  87         if ( !ms_proxyDefault )
  88         {
  89             // don't try again
  90             ms_useDefaultProxy = false;
  91         }
  92     }
  93
  94     m_useProxy = ms_proxyDefault != NULL;
  95     m_proxy = ms_proxyDefault;
  96 #endif // wxUSE_SOCKETS
  97
  98 }
  99
 100 // --------------------------------------------------------------
 101 // Assignment
 102 // --------------------------------------------------------------
 103
 104 wxURL& wxURL::operator = (const wxURI& url)
 105 {
 106     wxURI::operator = (url);
 107     Init(url.BuildURI());
 108     ParseURL();
 109     return *this;
 110 }
 111 wxURL& wxURL::operator = (const wxString& url)
 112 {
 113     wxURI::operator = (url);
 114     Init(url);
 115     ParseURL();
 116     return *this;
 117 }
 118
 119 // --------------------------------------------------------------
 120 // ParseURL
 121 //
 122 // Builds the URL and takes care of the old protocol stuff
 123 // --------------------------------------------------------------
 124
 125 bool wxURL::ParseURL()
 126 {
 127   // If the URL was already parsed (m_protocol != NULL), pass this section.
 128   if (!m_protocol)
 129   {
 130     // Clean up
 131     CleanData();
 132
 133     // Make sure we have a protocol/scheme
 134     if (!HasScheme())
 135     {
 136       m_error = wxURL_SNTXERR;
 137       return false;
 138     }
 139
 140     // Find and create the protocol object
 141     if (!FetchProtocol())
 142     {
 143       m_error = wxURL_NOPROTO;
 144       return false;
 145     }
 146
 147     // Do we need a host name ?
 148     if (m_protoinfo->m_needhost)
 149     {
 150       //  Make sure we have one, then
 151       if (!HasServer())
 152       {
 153         m_error = wxURL_SNTXERR;
 154         return false;
 155       }
 156     }
 157   }
 158
 159 #if wxUSE_SOCKETS
 160   if (m_useProxy)
 161   {
 162     // destroy the previously created protocol as we'll be using m_proxy
 163     delete m_protocol;
 164
 165     // Third, we rebuild the URL.
 166     m_url = m_scheme + wxT(":");
 167     if (m_protoinfo->m_needhost)
 168       m_url = m_url + wxT("//") + m_server;
 169
 170     // We initialize specific variables.
 171     m_protocol = m_proxy; // FIXME: we should clone the protocol
 172   }
 173 #endif
 174
 175   m_error = wxURL_NOERR;
 176   return true;
 177 }
 178
 179 // --------------------------------------------------------------
 180 // Destruction/Cleanup
 181 // --------------------------------------------------------------
 182
 183 void wxURL::CleanData()
 184 {
 185 #if wxUSE_SOCKETS
 186   if (!m_useProxy)
 187 #endif
 188     delete m_protocol;
 189 }
 190
 191 wxURL::~wxURL()
 192 {
 193     CleanData();
 194 #if wxUSE_SOCKETS
 195     if (m_proxy && m_proxy != ms_proxyDefault)
 196         delete m_proxy;
 197 #endif
 198 #if wxUSE_URL_NATIVE
 199     delete m_nativeImp;
 200 #endif
 201 }
 202
 203 // --------------------------------------------------------------
 204 // FetchProtocol
 205 // --------------------------------------------------------------
 206
 207 bool wxURL::FetchProtocol()
 208 {
 209   wxProtoInfo *info = ms_protocols;
 210
 211   while (info)
 212   {
 213     if (m_scheme == info->m_protoname)
 214     {
 215         if (m_port.IsNull())
 216             m_port = info->m_servname;
 217         m_protoinfo = info;
 218         m_protocol = (wxProtocol *)m_protoinfo->m_cinfo->CreateObject();
 219         return true;
 220     }
 221     info = info->next;
 222   }
 223   return false;
 224 }
 225
 226 // --------------------------------------------------------------
 227 // GetInputStream
 228 // --------------------------------------------------------------
 229
 230 wxInputStream *wxURL::GetInputStream()
 231 {
 232   if (!m_protocol)
 233   {
 234     m_error = wxURL_NOPROTO;
 235     return NULL;
 236   }
 237
 238   m_error = wxURL_NOERR;
 239   if (HasUser())
 240   {
 241       size_t dwPasswordPos = m_user.find(':');
 242
 243       if (dwPasswordPos == wxString::npos)
 244           m_protocol->SetUser(m_user);
 245       else
 246       {
 247           m_protocol->SetUser(m_user(0, dwPasswordPos));
 248           m_protocol->SetPassword(m_user(dwPasswordPos+1, m_user.length() + 1));
 249       }
 250   }
 251
 252 #if wxUSE_URL_NATIVE
 253   // give the native implementation to return a better stream
 254   // such as the native WinINet functionality under MS-Windows
 255   if (m_nativeImp)
 256   {
 257     wxInputStream *rc;
 258     rc = m_nativeImp->GetInputStream(this);
 259     if (rc != 0)
 260         return rc;
 261   }
 262   // else use the standard behaviour
 263 #endif // wxUSE_URL_NATIVE
 264
 265 #if wxUSE_SOCKETS
 266     wxIPV4address addr;
 267
 268   // m_protoinfo is NULL when we use a proxy
 269   if (!m_useProxy && m_protoinfo->m_needhost)
 270   {
 271     if (!addr.Hostname(m_server))
 272     {
 273       m_error = wxURL_NOHOST;
 274       return NULL;
 275     }
 276
 277     addr.Service(m_port);
 278
 279     if (!m_protocol->Connect(addr, true)) // Watcom needs the 2nd arg for some reason
 280     {
 281       m_error = wxURL_CONNERR;
 282       return NULL;
 283     }
 284   }
 285 #endif
 286
 287   // When we use a proxy, we have to pass the whole URL to it.
 288   wxInputStream *the_i_stream =
 289        (m_useProxy) ? m_protocol->GetInputStream(m_url) :
 290                       m_protocol->GetInputStream(m_path);
 291
 292   if (!the_i_stream)
 293   {
 294     m_error = wxURL_PROTOERR;
 295     return NULL;
 296   }
 297
 298   return the_i_stream;
 299 }
 300
 301 #if wxUSE_SOCKETS
 302 void wxURL::SetDefaultProxy(const wxString& url_proxy)
 303 {
 304   if ( !url_proxy )
 305   {
 306       if ( ms_proxyDefault )
 307       {
 308           ms_proxyDefault->Close();
 309           delete ms_proxyDefault;
 310           ms_proxyDefault = NULL;
 311       }
 312   }
 313   else
 314   {
 315       wxString tmp_str = url_proxy;
 316       int pos = tmp_str.Find(wxT(':'));
 317       if (pos == wxNOT_FOUND)
 318           return;
 319
 320       wxString hostname = tmp_str(0, pos),
 321       port = tmp_str(pos+1, tmp_str.Length()-pos);
 322       wxIPV4address addr;
 323
 324       if (!addr.Hostname(hostname))
 325           return;
 326       if (!addr.Service(port))
 327           return;
 328
 329       if (ms_proxyDefault)
 330           // Finally, when all is right, we connect the new proxy.
 331           ms_proxyDefault->Close();
 332       else
 333           ms_proxyDefault = new wxHTTP();
 334       ms_proxyDefault->Connect(addr, true); // Watcom needs the 2nd arg for some reason
 335   }
 336 }
 337
 338 void wxURL::SetProxy(const wxString& url_proxy)
 339 {
 340     if ( !url_proxy )
 341     {
 342         if ( m_proxy && m_proxy != ms_proxyDefault )
 343         {
 344             m_proxy->Close();
 345             delete m_proxy;
 346         }
 347
 348         m_useProxy = false;
 349     }
 350     else
 351     {
 352         wxString tmp_str;
 353         wxString hostname, port;
 354         int pos;
 355         wxIPV4address addr;
 356
 357         tmp_str = url_proxy;
 358         pos = tmp_str.Find(wxT(':'));
 359         // This is an invalid proxy name.
 360         if (pos == wxNOT_FOUND)
 361             return;
 362
 363         hostname = tmp_str(0, pos);
 364         port = tmp_str(pos+1, tmp_str.Length()-pos);
 365
 366         addr.Hostname(hostname);
 367         addr.Service(port);
 368
 369         // Finally, create the whole stuff.
 370         if (m_proxy && m_proxy != ms_proxyDefault)
 371             delete m_proxy;
 372         m_proxy = new wxHTTP();
 373         m_proxy->Connect(addr, true); // Watcom needs the 2nd arg for some reason
 374
 375         CleanData();
 376         // Reparse url.
 377         m_useProxy = true;
 378         ParseURL();
 379     }
 380 }
 381 #endif // wxUSE_SOCKETS
 382
 383 // ----------------------------------------------------------------------
 384 // wxURLModule
 385 //
 386 // A module which deletes the default proxy if we created it
 387 // ----------------------------------------------------------------------
 388
 389 #if wxUSE_SOCKETS
 390
 391 class wxURLModule : public wxModule
 392 {
 393 public:
 394     virtual bool OnInit();
 395     virtual void OnExit();
 396
 397 private:
 398     DECLARE_DYNAMIC_CLASS(wxURLModule)
 399 };
 400
 401 IMPLEMENT_DYNAMIC_CLASS(wxURLModule, wxModule)
 402
 403 bool wxURLModule::OnInit()
 404 {
 405     // env var HTTP_PROXY contains the address of the default proxy to use if
 406     // set, but don't try to create this proxy right now because it will slow
 407     // down the program startup (especially if there is no DNS server
 408     // available, in which case it may take up to 1 minute)
 409
 410     if ( getenv("HTTP_PROXY") )
 411     {
 412         wxURL::ms_useDefaultProxy = true;
 413     }
 414
 415     return true;
 416 }
 417
 418 void wxURLModule::OnExit()
 419 {
 420     delete wxURL::ms_proxyDefault;
 421     wxURL::ms_proxyDefault = NULL;
 422 }
 423
 424 #endif // wxUSE_SOCKETS
 425
 426 #endif // wxUSE_URL
 427