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     // destroy the previously created protocol as we'll be using m_proxy
 166     delete m_protocol;
 167
 168     // Third, we rebuild the URL.
 169     m_url = m_scheme + wxT(":");
 170     if (m_protoinfo->m_needhost)
 171       m_url = m_url + wxT("//") + m_server;
 172
 173     // We initialize specific variables.
 174     m_protocol = m_proxy; // FIXME: we should clone the protocol
 175   }
 176 #endif // wxUSE_PROTOCOL_HTTP
 177
 178   m_error = wxURL_NOERR;
 179   return true;
 180 }
 181
 182 // --------------------------------------------------------------
 183 // Destruction/Cleanup
 184 // --------------------------------------------------------------
 185
 186 void wxURL::CleanData()
 187 {
 188 #if wxUSE_PROTOCOL_HTTP
 189   if (!m_useProxy)
 190 #endif // wxUSE_PROTOCOL_HTTP
 191     delete m_protocol;
 192 }
 193
 194 wxURL::~wxURL()
 195 {
 196     CleanData();
 197 #if wxUSE_PROTOCOL_HTTP
 198     if (m_proxy && m_proxy != ms_proxyDefault)
 199         delete m_proxy;
 200 #endif // wxUSE_PROTOCOL_HTTP
 201 #if wxUSE_URL_NATIVE
 202     delete m_nativeImp;
 203 #endif
 204 }
 205
 206 // --------------------------------------------------------------
 207 // FetchProtocol
 208 // --------------------------------------------------------------
 209
 210 bool wxURL::FetchProtocol()
 211 {
 212   wxProtoInfo *info = ms_protocols;
 213
 214   while (info)
 215   {
 216     if (m_scheme == info->m_protoname)
 217     {
 218         if (m_port.IsNull())
 219             m_port = info->m_servname;
 220         m_protoinfo = info;
 221         m_protocol = (wxProtocol *)m_protoinfo->m_cinfo->CreateObject();
 222         return true;
 223     }
 224     info = info->next;
 225   }
 226   return false;
 227 }
 228
 229 // --------------------------------------------------------------
 230 // GetInputStream
 231 // --------------------------------------------------------------
 232
 233 wxInputStream *wxURL::GetInputStream()
 234 {
 235   if (!m_protocol)
 236   {
 237     m_error = wxURL_NOPROTO;
 238     return NULL;
 239   }
 240
 241   m_error = wxURL_NOERR;
 242   if (HasUser())
 243   {
 244       size_t dwPasswordPos = m_user.find(':');
 245
 246       if (dwPasswordPos == wxString::npos)
 247           m_protocol->SetUser(m_user);
 248       else
 249       {
 250           m_protocol->SetUser(m_user(0, dwPasswordPos));
 251           m_protocol->SetPassword(m_user(dwPasswordPos+1, m_user.length() + 1));
 252       }
 253   }
 254
 255 #if wxUSE_URL_NATIVE
 256   // give the native implementation to return a better stream
 257   // such as the native WinINet functionality under MS-Windows
 258   if (m_nativeImp)
 259   {
 260     wxInputStream *rc;
 261     rc = m_nativeImp->GetInputStream(this);
 262     if (rc != 0)
 263         return rc;
 264   }
 265   // else use the standard behaviour
 266 #endif // wxUSE_URL_NATIVE
 267
 268 #if wxUSE_SOCKETS
 269     wxIPV4address addr;
 270
 271   // m_protoinfo is NULL when we use a proxy
 272   if (!m_useProxy && m_protoinfo->m_needhost)
 273   {
 274     if (!addr.Hostname(m_server))
 275     {
 276       m_error = wxURL_NOHOST;
 277       return NULL;
 278     }
 279
 280     addr.Service(m_port);
 281
 282     if (!m_protocol->Connect(addr, true)) // Watcom needs the 2nd arg for some reason
 283     {
 284       m_error = wxURL_CONNERR;
 285       return NULL;
 286     }
 287   }
 288 #endif
 289
 290   // When we use a proxy, we have to pass the whole URL to it.
 291   wxInputStream *the_i_stream;
 292
 293   if (!m_useProxy)
 294   {
 295       the_i_stream = m_protocol->GetInputStream(m_url);
 296   }
 297   else
 298   {
 299       wxString fullPath = m_path;
 300
 301       if (HasQuery())
 302           fullPath += wxT("?") + m_query;
 303
 304       if (HasFragment())
 305           fullPath += wxT("#") + m_fragment;
 306
 307       the_i_stream = m_protocol->GetInputStream(fullPath);
 308   }
 309
 310   if (!the_i_stream)
 311   {
 312     m_error = wxURL_PROTOERR;
 313     return NULL;
 314   }
 315
 316   return the_i_stream;
 317 }
 318
 319 #if wxUSE_PROTOCOL_HTTP
 320 void wxURL::SetDefaultProxy(const wxString& url_proxy)
 321 {
 322   if ( !url_proxy )
 323   {
 324       if ( ms_proxyDefault )
 325       {
 326           ms_proxyDefault->Close();
 327           delete ms_proxyDefault;
 328           ms_proxyDefault = NULL;
 329       }
 330   }
 331   else
 332   {
 333       wxString tmp_str = url_proxy;
 334       int pos = tmp_str.Find(wxT(':'));
 335       if (pos == wxNOT_FOUND)
 336           return;
 337
 338       wxString hostname = tmp_str(0, pos),
 339       port = tmp_str(pos+1, tmp_str.Length()-pos);
 340       wxIPV4address addr;
 341
 342       if (!addr.Hostname(hostname))
 343           return;
 344       if (!addr.Service(port))
 345           return;
 346
 347       if (ms_proxyDefault)
 348           // Finally, when all is right, we connect the new proxy.
 349           ms_proxyDefault->Close();
 350       else
 351           ms_proxyDefault = new wxHTTP();
 352       ms_proxyDefault->Connect(addr, true); // Watcom needs the 2nd arg for some reason
 353   }
 354 }
 355
 356 void wxURL::SetProxy(const wxString& url_proxy)
 357 {
 358     if ( !url_proxy )
 359     {
 360         if ( m_proxy && m_proxy != ms_proxyDefault )
 361         {
 362             m_proxy->Close();
 363             delete m_proxy;
 364         }
 365
 366         m_useProxy = false;
 367     }
 368     else
 369     {
 370         wxString tmp_str;
 371         wxString hostname, port;
 372         int pos;
 373         wxIPV4address addr;
 374
 375         tmp_str = url_proxy;
 376         pos = tmp_str.Find(wxT(':'));
 377         // This is an invalid proxy name.
 378         if (pos == wxNOT_FOUND)
 379             return;
 380
 381         hostname = tmp_str(0, pos);
 382         port = tmp_str(pos+1, tmp_str.Length()-pos);
 383
 384         addr.Hostname(hostname);
 385         addr.Service(port);
 386
 387         // Finally, create the whole stuff.
 388         if (m_proxy && m_proxy != ms_proxyDefault)
 389             delete m_proxy;
 390         m_proxy = new wxHTTP();
 391         m_proxy->Connect(addr, true); // Watcom needs the 2nd arg for some reason
 392
 393         CleanData();
 394         // Reparse url.
 395         m_useProxy = true;
 396         ParseURL();
 397     }
 398 }
 399 #endif // wxUSE_PROTOCOL_HTTP
 400
 401 // ----------------------------------------------------------------------
 402 // wxURLModule
 403 //
 404 // A module which deletes the default proxy if we created it
 405 // ----------------------------------------------------------------------
 406
 407 #if wxUSE_SOCKETS
 408
 409 class wxURLModule : public wxModule
 410 {
 411 public:
 412     virtual bool OnInit();
 413     virtual void OnExit();
 414
 415 private:
 416     DECLARE_DYNAMIC_CLASS(wxURLModule)
 417 };
 418
 419 IMPLEMENT_DYNAMIC_CLASS(wxURLModule, wxModule)
 420
 421 bool wxURLModule::OnInit()
 422 {
 423 #if wxUSE_PROTOCOL_HTTP
 424     // env var HTTP_PROXY contains the address of the default proxy to use if
 425     // set, but don't try to create this proxy right now because it will slow
 426     // down the program startup (especially if there is no DNS server
 427     // available, in which case it may take up to 1 minute)
 428
 429     if ( getenv("HTTP_PROXY") )
 430     {
 431         wxURL::ms_useDefaultProxy = true;
 432     }
 433 #endif // wxUSE_PROTOCOL_HTTP
 434     return true;
 435 }
 436
 437 void wxURLModule::OnExit()
 438 {
 439 #if wxUSE_PROTOCOL_HTTP
 440     delete wxURL::ms_proxyDefault;
 441     wxURL::ms_proxyDefault = NULL;
 442 #endif // wxUSE_PROTOCOL_HTTP
 443 }
 444
 445 #endif // wxUSE_SOCKETS
 446
 447 #endif // wxUSE_URL
 448