src/common/url.cpp

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