X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/375abe3dac3d7816738ccd1ab495d9a0441550d4..9a35701127e3e8d2c7fb433d85c7b3954ccbfc9f:/src/common/url.cpp diff --git a/src/common/url.cpp b/src/common/url.cpp index 8c7ddb27d2..9e02d03dca 100644 --- a/src/common/url.cpp +++ b/src/common/url.cpp @@ -6,10 +6,10 @@ // Created: 20/07/1997 // RCS-ID: $Id$ // Copyright: (c) 1997, 1998 Guilhem Lavaux -// Licence: wxWindows license +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// -#ifdef __GNUG__ +#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) #pragma implementation "url.h" #endif @@ -20,121 +20,174 @@ #pragma hdrstop #endif -#ifndef WX_PRECOMP -#endif +#if wxUSE_URL + +#include "wx/string.h" +#include "wx/list.h" +#include "wx/utils.h" +#include "wx/module.h" +#include "wx/url.h" #include #include -// wxWindows headers -#include -#include -#include - -// wxSocket header -#include "wx/url.h" - -#if !USE_SHARED_LIBRARY IMPLEMENT_CLASS(wxProtoInfo, wxObject) IMPLEMENT_CLASS(wxURL, wxObject) -#endif // Protocols list -wxProtoInfo *wxURL::g_protocols = NULL; -wxHTTP *wxURL::g_proxy; +wxProtoInfo *wxURL::ms_protocols = NULL; + +// Enforce linking of protocol classes: +USE_PROTOCOL(wxFileProto) + +#if wxUSE_SOCKETS +USE_PROTOCOL(wxHTTP) +USE_PROTOCOL(wxFTP) -///////////////////////////////////////////////////////////////// -// wxURL //////////////////////////////////////////////////////// -///////////////////////////////////////////////////////////////// + wxHTTP *wxURL::ms_proxyDefault = NULL; + bool wxURL::ms_useDefaultProxy = false; +#endif + +// -------------------------------------------------------------- +// wxURL +// -------------------------------------------------------------- -/* - * -------------------------------------------------------------- - * --------- wxURL CONSTRUCTOR DESTRUCTOR ----------------------- - * -------------------------------------------------------------- - */ +// -------------------------------------------------------------- +// --------- wxURL CONSTRUCTOR DESTRUCTOR ----------------------- +// -------------------------------------------------------------- wxURL::wxURL(const wxString& url) { - m_protocol = NULL; - if (g_proxy->IsConnected()) { - m_protocol = g_proxy; - m_protoname = "proxy"; - m_path = url; - return; - } - m_url = url; - m_error = wxURL_NOERR; - ParseURL(); + m_protocol = NULL; + m_error = wxURL_NOERR; + m_url = url; +#if wxUSE_URL_NATIVE + m_nativeImp = CreateNativeImpObject(); +#endif + +#if wxUSE_SOCKETS + if ( ms_useDefaultProxy && !ms_proxyDefault ) + { + SetDefaultProxy( wxGetenv(wxT("HTTP_PROXY")) ); + + if ( !ms_proxyDefault ) + { + // don't try again + ms_useDefaultProxy = false; + } + } + + m_useProxy = ms_proxyDefault != NULL; + m_proxy = ms_proxyDefault; +#endif // wxUSE_SOCKETS + + ParseURL(); } bool wxURL::ParseURL() { wxString last_url = m_url; - // Clean up - CleanData(); + // If the URL was already parsed (m_protocol != NULL), pass this section. + if (!m_protocol) + { + // Clean up + CleanData(); - // Extract protocol name - if (!PrepProto(last_url)) { - m_error = wxURL_SNTXERR; - return FALSE; - } + // Extract protocol name + if (!PrepProto(last_url)) + { + m_error = wxURL_SNTXERR; + return false; + } - // Find and create the protocol object - if (!FetchProtocol()) { - m_error = wxURL_NOPROTO; - return FALSE; - } + // Find and create the protocol object + if (!FetchProtocol()) + { + m_error = wxURL_NOPROTO; + return false; + } - // Do we need a host name ? - if (m_protoinfo->m_needhost) { - // Extract it - if (!PrepHost(last_url)) { - m_error = wxURL_SNTXERR; - return FALSE; + // Do we need a host name ? + if (m_protoinfo->m_needhost) + { + // Extract it + if (!PrepHost(last_url)) + { + m_error = wxURL_SNTXERR; + return false; + } + } + + // Extract full path + if (!PrepPath(last_url)) + { + m_error = wxURL_NOPATH; + return false; } } + // URL parse finished. + +#if wxUSE_SOCKETS + if (m_useProxy) + { + // destroy the previously created protocol as we'll be using m_proxy + delete m_protocol; - // Extract full path - if (!PrepPath(last_url)) { - m_error = wxURL_NOPATH; - return FALSE; + // Third, we rebuild the URL. + m_url = m_protoname + wxT(":"); + if (m_protoinfo->m_needhost) + m_url = m_url + wxT("//") + m_hostname; + + m_url += m_path; + + // We initialize specific variables. + m_protocol = m_proxy; // FIXME: we should clone the protocol } +#endif m_error = wxURL_NOERR; - return TRUE; + return true; } void wxURL::CleanData() { - if (m_protoname != "proxy") +#if wxUSE_SOCKETS + if (!m_useProxy) +#endif delete m_protocol; } wxURL::~wxURL() { - CleanData(); + CleanData(); +#if wxUSE_SOCKETS + if (m_proxy && m_proxy != ms_proxyDefault) + delete m_proxy; +#endif +#if wxUSE_URL_NATIVE + delete m_nativeImp; +#endif } -/* - * -------------------------------------------------------------- - * --------- wxURL urls decoders -------------------------------- - * -------------------------------------------------------------- - */ +// -------------------------------------------------------------- +// --------- wxURL urls decoders -------------------------------- +// -------------------------------------------------------------- + bool wxURL::PrepProto(wxString& url) { int pos; // Find end - pos = url.Find(':'); - if (pos == -1) - return FALSE; + pos = url.Find(wxT(':')); + if (pos == wxNOT_FOUND) + return false; m_protoname = url(0, pos); url = url(pos+1, url.Length()); - return TRUE; + return true; } bool wxURL::PrepHost(wxString& url) @@ -142,123 +195,144 @@ bool wxURL::PrepHost(wxString& url) wxString temp_url; int pos, pos2; - if ((url.GetChar(0) != '/') || (url.GetChar(1) != '/')) - return FALSE; + if ((url.GetChar(0) != wxT('/')) || (url.GetChar(1) != wxT('/'))) + return false; url = url(2, url.Length()); - pos = url.Find('/'); - if (pos == -1) + pos = url.Find(wxT('/')); + if (pos == wxNOT_FOUND) pos = url.Length(); if (pos == 0) - return FALSE; + return false; temp_url = url(0, pos); - url = url(url.Find('/'), url.Length()); + url = url(url.Find(wxT('/')), url.Length()); // Retrieve service number - pos2 = temp_url.Find(':', TRUE); - if (pos2 != -1 && pos2 < pos) { + pos2 = temp_url.Find(wxT(':'), true); + if (pos2 != wxNOT_FOUND && pos2 < pos) + { m_servname = temp_url(pos2+1, pos); if (!m_servname.IsNumber()) - return FALSE; + return false; temp_url = temp_url(0, pos2); } // Retrieve user and password. - pos2 = temp_url.Find('@'); - // Even if pos2 equals -1, this code is right. + pos2 = temp_url.Find(wxT('@')); + // Even if pos2 equals wxNOT_FOUND, this code is right. m_hostname = temp_url(pos2+1, temp_url.Length()); - m_user = ""; - m_password = ""; + m_user = wxT(""); + m_password = wxT(""); - if (pos2 == -1) - return TRUE; + if (pos2 == wxNOT_FOUND) + return true; temp_url = temp_url(0, pos2); - pos2 = temp_url.Find(':'); + pos2 = temp_url.Find(wxT(':')); - if (pos2 == -1) - return FALSE; + if (pos2 == wxNOT_FOUND) + return false; m_user = temp_url(0, pos2); m_password = temp_url(pos2+1, url.Length()); - return TRUE; + return true; } bool wxURL::PrepPath(wxString& url) { if (url.Length() != 0) - m_path = url; + m_path = ConvertToValidURI(url); else - m_path = "/"; - return TRUE; + m_path = wxT("/"); + return true; } bool wxURL::FetchProtocol() { - wxProtoInfo *info = g_protocols; + wxProtoInfo *info = ms_protocols; - while (info) { - if (m_protoname == info->m_protoname) { + while (info) + { + if (m_protoname == info->m_protoname) + { if (m_servname.IsNull()) m_servname = info->m_servname; m_protoinfo = info; m_protocol = (wxProtocol *)m_protoinfo->m_cinfo->CreateObject(); - wxSocketHandler::Master().Register(m_protocol); - return TRUE; + return true; } info = info->next; } - return FALSE; + return false; } -/* - * -------------------------------------------------------------- - * --------- wxURL get ------------------------------------------ - * -------------------------------------------------------------- - */ -wxInputStream *wxURL::GetInputStream(void) -{ - wxIPV4address addr; - wxInputStream *the_i_stream = NULL; +// -------------------------------------------------------------- +// --------- wxURL get ------------------------------------------ +// -------------------------------------------------------------- +wxInputStream *wxURL::GetInputStream() +{ if (!m_protocol) - if (!ParseURL()) - return NULL; - - if (!m_protocol) { + { m_error = wxURL_NOPROTO; return NULL; } m_error = wxURL_NOERR; - if (m_user != "") { + if (m_user != wxT("")) + { m_protocol->SetUser(m_user); m_protocol->SetPassword(m_password); } - if (m_protoinfo->m_needhost) { - if (!addr.Hostname(m_hostname)) { +#if wxUSE_URL_NATIVE + // give the native implementation to return a better stream + // such as the native WinINet functionality under MS-Windows + if (m_nativeImp) + { + wxInputStream *rc; + rc = m_nativeImp->GetInputStream(this); + if (rc != 0) + return rc; + } + // else use the standard behaviour +#endif // wxUSE_URL_NATIVE + +#if wxUSE_SOCKETS + wxIPV4address addr; + + // m_protoinfo is NULL when we use a proxy + if (!m_useProxy && m_protoinfo->m_needhost) + { + if (!addr.Hostname(m_hostname)) + { m_error = wxURL_NOHOST; return NULL; } addr.Service(m_servname); - if (!m_protocol->Connect(addr, TRUE)) // Watcom needs the 2nd arg for some reason + if (!m_protocol->Connect(addr, true)) // Watcom needs the 2nd arg for some reason { m_error = wxURL_CONNERR; return NULL; } } +#endif - the_i_stream = m_protocol->GetInputStream(m_path); - if (!the_i_stream) { + // When we use a proxy, we have to pass the whole URL to it. + wxInputStream *the_i_stream = + (m_useProxy) ? m_protocol->GetInputStream(m_url) : + m_protocol->GetInputStream(m_path); + + if (!the_i_stream) + { m_error = wxURL_PROTOERR; return NULL; } @@ -266,50 +340,209 @@ wxInputStream *wxURL::GetInputStream(void) return the_i_stream; } +#if wxUSE_SOCKETS void wxURL::SetDefaultProxy(const wxString& url_proxy) { - g_proxy->Close(); + if ( !url_proxy ) + { + if ( ms_proxyDefault ) + { + ms_proxyDefault->Close(); + delete ms_proxyDefault; + ms_proxyDefault = NULL; + } + } + else + { + wxString tmp_str = url_proxy; + int pos = tmp_str.Find(wxT(':')); + if (pos == wxNOT_FOUND) + return; + + wxString hostname = tmp_str(0, pos), + port = tmp_str(pos+1, tmp_str.Length()-pos); + wxIPV4address addr; + + if (!addr.Hostname(hostname)) + return; + if (!addr.Service(port)) + return; + + if (ms_proxyDefault) + // Finally, when all is right, we connect the new proxy. + ms_proxyDefault->Close(); + else + ms_proxyDefault = new wxHTTP(); + ms_proxyDefault->Connect(addr, true); // Watcom needs the 2nd arg for some reason + } +} + +void wxURL::SetProxy(const wxString& url_proxy) +{ + if ( !url_proxy ) + { + if ( m_proxy && m_proxy != ms_proxyDefault ) + { + m_proxy->Close(); + delete m_proxy; + } + + m_useProxy = false; + } + else + { + wxString tmp_str; + wxString hostname, port; + int pos; + wxIPV4address addr; + + tmp_str = url_proxy; + pos = tmp_str.Find(wxT(':')); + // This is an invalid proxy name. + if (pos == wxNOT_FOUND) + return; + + hostname = tmp_str(0, pos); + port = tmp_str(pos+1, tmp_str.Length()-pos); + + addr.Hostname(hostname); + addr.Service(port); + + // Finally, create the whole stuff. + if (m_proxy && m_proxy != ms_proxyDefault) + delete m_proxy; + m_proxy = new wxHTTP(); + m_proxy->Connect(addr, true); // Watcom needs the 2nd arg for some reason + + CleanData(); + // Reparse url. + m_useProxy = true; + ParseURL(); + } +} +#endif // wxUSE_SOCKETS + +wxString wxURL::ConvertToValidURI(const wxString& uri, const wxChar* delims) +{ + wxString out_str; + wxString hexa_code; + size_t i; + + for (i = 0; i < uri.Len(); i++) + { + wxChar c = uri.GetChar(i); - if (url_proxy.IsNull()) - return; + if (c == wxT(' ')) + { + // GRG, Apr/2000: changed to "%20" instead of '+' - wxString tmp_str = url_proxy; - int pos = tmp_str.Find(':'); - wxString hostname = tmp_str(0, pos), - port = tmp_str(pos, tmp_str.Length()-pos); - wxIPV4address addr; + out_str += wxT("%20"); + } + else + { + // GRG, Apr/2000: modified according to the URI definition (RFC 2396) + // + // - Alphanumeric characters are never escaped + // - Unreserved marks are never escaped + // - Delimiters must be escaped if they appear within a component + // but not if they are used to separate components. Here we have + // no clear way to distinguish between these two cases, so they + // are escaped unless they are passed in the 'delims' parameter + // (allowed delimiters). + + static const wxChar marks[] = wxT("-_.!~*()'"); + + if ( !wxIsalnum(c) && !wxStrchr(marks, c) && !wxStrchr(delims, c) ) + { + hexa_code.Printf(wxT("%%%02X"), c); + out_str += hexa_code; + } + else + { + out_str += c; + } + } + } - addr.Hostname(hostname); - addr.Service(port); - - g_proxy->Connect(addr, TRUE); // Watcom needs the 2nd arg for some reason + return out_str; } -void wxURL::SetProxy(const wxString& url_proxy) +wxString wxURL::ConvertFromURI(const wxString& uri) { - if (url_proxy.IsNull()) { - m_proxy.Close(); - return; + wxString new_uri; + + size_t i = 0; + while (i < uri.Len()) + { + int code; + if (uri[i] == wxT('%')) + { + i++; + if (uri[i] >= wxT('A') && uri[i] <= wxT('F')) + code = (uri[i] - wxT('A') + 10) * 16; + else if (uri[i] >= wxT('a') && uri[i] <= wxT('f')) + code = (uri[i] - wxT('a') + 10) * 16; + else + code = (uri[i] - wxT('0')) * 16; + + i++; + if (uri[i] >= wxT('A') && uri[i] <= wxT('F')) + code += (uri[i] - wxT('A')) + 10; + else if (uri[i] >= wxT('a') && uri[i] <= wxT('f')) + code += (uri[i] - wxT('a')) + 10; + else + code += (uri[i] - wxT('0')); + + i++; + new_uri += (wxChar)code; + continue; + } + new_uri += uri[i]; + i++; } + return new_uri; +} - CleanData(); +// ---------------------------------------------------------------------- +// A module which deletes the default proxy if we created it +// ---------------------------------------------------------------------- - wxString tmp_str; - wxString hostname, port; - int pos; - wxIPV4address addr; +#if wxUSE_SOCKETS - tmp_str = url_proxy; - pos = tmp_str.Find(':'); - hostname = tmp_str(0, pos); - port = tmp_str(pos, tmp_str.Length()-pos); +class wxURLModule : public wxModule +{ +public: + virtual bool OnInit(); + virtual void OnExit(); - addr.Hostname(hostname); - addr.Service(port); +private: + DECLARE_DYNAMIC_CLASS(wxURLModule) +}; - m_proxy.Connect(addr, TRUE); // Watcom needs the 2nd arg for some reason +IMPLEMENT_DYNAMIC_CLASS(wxURLModule, wxModule) - m_protocol = &m_proxy; - m_protoname = "proxy"; - m_path = url_proxy; +bool wxURLModule::OnInit() +{ + // env var HTTP_PROXY contains the address of the default proxy to use if + // set, but don't try to create this proxy right now because it will slow + // down the program startup (especially if there is no DNS server + // available, in which case it may take up to 1 minute) + + if ( getenv("HTTP_PROXY") ) + { + wxURL::ms_useDefaultProxy = true; + } + + return true; } + +void wxURLModule::OnExit() +{ + delete wxURL::ms_proxyDefault; + wxURL::ms_proxyDefault = NULL; +} + +#endif // wxUSE_SOCKETS + +#endif // wxUSE_URL +