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_PROTOCOL_HTTP
  44 USE_PROTOCOL(wxHTTP)
  45
  46     wxHTTP *wxURL::ms_proxyDefault = NULL;
  47     bool wxURL::ms_useDefaultProxy = false;
  48 #endif
  49
  50 #if wxUSE_PROTOCOL_FTP
  51 USE_PROTOCOL(wxFTP)
  52 #endif
  53
  54 // --------------------------------------------------------------
  55 //
  56 //                          wxURL
  57 //
  58 // --------------------------------------------------------------
  59
  60 // --------------------------------------------------------------
  61 // Construction
  62 // --------------------------------------------------------------
  63
  64 wxURL::wxURL(const wxString& url) : wxURI(url)
  65 {
  66     Init(url);
  67     ParseURL();
  68 }
  69
  70 wxURL::wxURL(const wxURI& url) : wxURI(url)
  71 {
  72     Init(url.BuildURI());
  73     ParseURL();
  74 }
  75
  76 void wxURL::Init(const wxString& url)
  77 {
  78     m_protocol = NULL;
  79     m_error = wxURL_NOERR;
  80     m_url = url;
  81 #if wxUSE_URL_NATIVE
  82     m_nativeImp = CreateNativeImpObject();
  83 #endif
  84
  85 #if wxUSE_PROTOCOL_HTTP
  86     if ( ms_useDefaultProxy && !ms_proxyDefault )
  87     {
  88         SetDefaultProxy( wxGetenv(wxT("HTTP_PROXY")) );
  89
  90         if ( !ms_proxyDefault )
  91         {
  92             // don't try again
  93             ms_useDefaultProxy = false;
  94         }
  95     }
  96
  97     m_useProxy = ms_proxyDefault != NULL;
  98     m_proxy = ms_proxyDefault;
  99 #endif // wxUSE_PROTOCOL_HTTP
 100
 101 }
 102
 103 // --------------------------------------------------------------
 104 // Assignment
 105 // --------------------------------------------------------------
 106
 107 wxURL& wxURL::operator = (const wxURI& url)
 108 {
 109     wxURI::operator = (url);
 110     Init(url.BuildURI());
 111     ParseURL();
 112     return *this;
 113 }
 114 wxURL& wxURL::operator = (const wxString& url)
 115 {
 116     wxURI::operator = (url);
 117     Init(url);
 118     ParseURL();
 119     return *this;
 120 }
 121
 122 // --------------------------------------------------------------
 123 // ParseURL
 124 //
 125 // Builds the URL and takes care of the old protocol stuff
 126 // --------------------------------------------------------------
 127
 128 bool wxURL::ParseURL()
 129 {
 130   // If the URL was already parsed (m_protocol != NULL), pass this section.
 131   if (!m_protocol)
 132   {
 133     // Clean up
 134     CleanData();
 135
 136     // Make sure we have a protocol/scheme
 137     if (!HasScheme())
 138     {
 139       m_error = wxURL_SNTXERR;
 140       return false;
 141     }
 142
 143     // Find and create the protocol object
 144     if (!FetchProtocol())
 145     {
 146       m_error = wxURL_NOPROTO;
 147       return false;
 148     }
 149
 150     // Do we need a host name ?
 151     if (m_protoinfo->m_needhost)
 152     {
 153       //  Make sure we have one, then
 154       if (!HasServer())
 155       {
 156         m_error = wxURL_SNTXERR;
 157         return false;
 158       }
 159     }
 160   }
 161
 162 #if wxUSE_PROTOCOL_HTTP
 163   if (m_useProxy)
 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 // wxUSE_PROTOCOL_HTTP
 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_PROTOCOL_HTTP
 186   if (!m_useProxy)
 187 #endif // wxUSE_PROTOCOL_HTTP
 188     delete m_protocol;
 189 }
 190
 191 wxURL::~wxURL()
 192 {
 193     CleanData();
 194 #if wxUSE_PROTOCOL_HTTP
 195     if (m_proxy && m_proxy != ms_proxyDefault)
 196         delete m_proxy;
 197 #endif // wxUSE_PROTOCOL_HTTP
 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 (HasUserInfo())
 240   {
 241       size_t dwPasswordPos = m_userinfo.find(':');
 242
 243       if (dwPasswordPos == wxString::npos)
 244           m_protocol->SetUser(m_userinfo);
 245       else
 246       {
 247           m_protocol->SetUser(m_userinfo(0, dwPasswordPos));
 248           m_protocol->SetPassword(m_userinfo(dwPasswordPos+1, m_userinfo.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
 290   if (!m_useProxy)
 291   {
 292       the_i_stream = m_protocol->GetInputStream(m_url);
 293   }
 294   else
 295   {
 296       wxString fullPath = m_path;
 297
 298       if (HasQuery())
 299           fullPath += wxT("?") + m_query;
 300
 301       if (HasFragment())
 302           fullPath += wxT("#") + m_fragment;
 303
 304       the_i_stream = m_protocol->GetInputStream(fullPath);
 305   }
 306
 307   if (!the_i_stream)
 308   {
 309     m_error = wxURL_PROTOERR;
 310     return NULL;
 311   }
 312
 313   return the_i_stream;
 314 }
 315
 316 #if wxUSE_PROTOCOL_HTTP
 317 void wxURL::SetDefaultProxy(const wxString& url_proxy)
 318 {
 319   if ( !url_proxy )
 320   {
 321       if ( ms_proxyDefault )
 322       {
 323           ms_proxyDefault->Close();
 324           delete ms_proxyDefault;
 325           ms_proxyDefault = NULL;
 326       }
 327   }
 328   else
 329   {
 330       wxString tmp_str = url_proxy;
 331       int pos = tmp_str.Find(wxT(':'));
 332       if (pos == wxNOT_FOUND)
 333           return;
 334
 335       wxString hostname = tmp_str(0, pos),
 336       port = tmp_str(pos+1, tmp_str.Length()-pos);
 337       wxIPV4address addr;
 338
 339       if (!addr.Hostname(hostname))
 340           return;
 341       if (!addr.Service(port))
 342           return;
 343
 344       if (ms_proxyDefault)
 345           // Finally, when all is right, we connect the new proxy.
 346           ms_proxyDefault->Close();
 347       else
 348           ms_proxyDefault = new wxHTTP();
 349       ms_proxyDefault->Connect(addr, true); // Watcom needs the 2nd arg for some reason
 350   }
 351 }
 352
 353 void wxURL::SetProxy(const wxString& url_proxy)
 354 {
 355     if ( !url_proxy )
 356     {
 357         if ( m_proxy && m_proxy != ms_proxyDefault )
 358         {
 359             m_proxy->Close();
 360             delete m_proxy;
 361         }
 362
 363         m_useProxy = false;
 364     }
 365     else
 366     {
 367         wxString tmp_str;
 368         wxString hostname, port;
 369         int pos;
 370         wxIPV4address addr;
 371
 372         tmp_str = url_proxy;
 373         pos = tmp_str.Find(wxT(':'));
 374         // This is an invalid proxy name.
 375         if (pos == wxNOT_FOUND)
 376             return;
 377
 378         hostname = tmp_str(0, pos);
 379         port = tmp_str(pos+1, tmp_str.Length()-pos);
 380
 381         addr.Hostname(hostname);
 382         addr.Service(port);
 383
 384         // Finally, create the whole stuff.
 385         if (m_proxy && m_proxy != ms_proxyDefault)
 386             delete m_proxy;
 387         m_proxy = new wxHTTP();
 388         m_proxy->Connect(addr, true); // Watcom needs the 2nd arg for some reason
 389
 390         CleanData();
 391         // Reparse url.
 392         m_useProxy = true;
 393         ParseURL();
 394     }
 395 }
 396 #endif // wxUSE_PROTOCOL_HTTP
 397
 398 // ----------------------------------------------------------------------
 399 // wxURLModule
 400 //
 401 // A module which deletes the default proxy if we created it
 402 // ----------------------------------------------------------------------
 403
 404 #if wxUSE_SOCKETS
 405
 406 class wxURLModule : public wxModule
 407 {
 408 public:
 409     virtual bool OnInit();
 410     virtual void OnExit();
 411
 412 private:
 413     DECLARE_DYNAMIC_CLASS(wxURLModule)
 414 };
 415
 416 IMPLEMENT_DYNAMIC_CLASS(wxURLModule, wxModule)
 417
 418 bool wxURLModule::OnInit()
 419 {
 420 #if wxUSE_PROTOCOL_HTTP
 421     // env var HTTP_PROXY contains the address of the default proxy to use if
 422     // set, but don't try to create this proxy right now because it will slow
 423     // down the program startup (especially if there is no DNS server
 424     // available, in which case it may take up to 1 minute)
 425
 426     if ( wxGetenv(_T("HTTP_PROXY")) )
 427     {
 428         wxURL::ms_useDefaultProxy = true;
 429     }
 430 #endif // wxUSE_PROTOCOL_HTTP
 431     return true;
 432 }
 433
 434 void wxURLModule::OnExit()
 435 {
 436 #if wxUSE_PROTOCOL_HTTP
 437     delete wxURL::ms_proxyDefault;
 438     wxURL::ms_proxyDefault = NULL;
 439 #endif // wxUSE_PROTOCOL_HTTP
 440 }
 441
 442 #endif // wxUSE_SOCKETS
 443
 444 #endif // wxUSE_URL
 445