X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/35a4dab713ccc16c2414aa18d360aa40929fd60c..cc4d5638c66a409e421420ed7110917755a66788:/src/common/http.cpp?ds=inline diff --git a/src/common/http.cpp b/src/common/http.cpp index 9d08ee7d80..0ecde88c77 100644 --- a/src/common/http.cpp +++ b/src/common/http.cpp @@ -1,283 +1,551 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: http.cpp +// Name: src/common/http.cpp // Purpose: HTTP protocol // Author: Guilhem Lavaux -// Modified by: +// Modified by: Simo Virokannas (authentication, Dec 2005) // Created: August 1997 -// RCS-ID: $Id$ // Copyright: (c) 1997, 1998 Guilhem Lavaux -// Licence: wxWindows license +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// -#ifdef __GNUG__ -#pragma implementation "http.h" -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" #ifdef __BORLANDC__ -#pragma hdrstop + #pragma hdrstop #endif -#if wxUSE_SOCKETS +#if wxUSE_PROTOCOL_HTTP + +#include +#include #ifndef WX_PRECOMP + #include "wx/string.h" + #include "wx/app.h" #endif -#include -#include -#include "wx/string.h" #include "wx/tokenzr.h" #include "wx/socket.h" #include "wx/protocol/protocol.h" +#include "wx/url.h" #include "wx/protocol/http.h" #include "wx/sckstrm.h" +#include "wx/thread.h" -#if !USE_SHARED_LIBRARY -IMPLEMENT_DYNAMIC_CLASS(wxHTTP, wxProtocol) -IMPLEMENT_PROTOCOL(wxHTTP, "http", "80", TRUE) -#endif -#define HTTP_BSIZE 2048 +// ---------------------------------------------------------------------------- +// wxHTTP +// ---------------------------------------------------------------------------- + +IMPLEMENT_DYNAMIC_CLASS(wxHTTP, wxProtocol) +IMPLEMENT_PROTOCOL(wxHTTP, wxT("http"), wxT("80"), true) wxHTTP::wxHTTP() - : wxProtocol(), - m_headers(wxKEY_STRING) + : wxProtocol() { - m_addr = NULL; - m_read = FALSE; + m_addr = NULL; + m_read = false; + m_proxy_mode = false; + m_http_response = 0; - SetNotify(REQ_LOST); + SetNotify(wxSOCKET_LOST_FLAG); } wxHTTP::~wxHTTP() { - // wxString isn't a wxObject - wxNode *node = m_headers.First(); - wxString *string; - - while (node) { - string = (wxString *)node->Data(); - delete string; - node = node->Next(); - } + ClearHeaders(); + + delete m_addr; } -wxString wxHTTP::GetContentType() +void wxHTTP::ClearHeaders() { - return GetHeader("Content-Type"); + m_headers.clear(); } -void wxHTTP::SetHeader(const wxString& header, const wxString& h_data) +void wxHTTP::ClearCookies() { - if (m_read) { - m_headers.Clear(); - m_read = FALSE; - } - - wxNode *node = m_headers.Find(header); - - if (!node) - m_headers.Append(header, (wxObject *)(new wxString(h_data))); - else { - wxString *str = (wxString *)node->Data(); - (*str) = h_data; - } + m_cookies.clear(); } -wxString wxHTTP::GetHeader(const wxString& header) +wxString wxHTTP::GetContentType() const { - wxNode *node = m_headers.Find(header); - if (!node) - return wxEmptyString; - - return *((wxString *)node->Data()); + return GetHeader(wxT("Content-Type")); } -void wxHTTP::SendHeaders() +void wxHTTP::SetProxyMode(bool on) { - wxNode *head = m_headers.First(); + m_proxy_mode = on; +} - while (head) - { - wxString *str = (wxString *)head->Data(); +wxHTTP::wxHeaderIterator wxHTTP::FindHeader(const wxString& header) +{ + wxHeaderIterator it = m_headers.begin(); + for ( wxHeaderIterator en = m_headers.end(); it != en; ++it ) + { + if ( header.CmpNoCase(it->first) == 0 ) + break; + } + + return it; +} - wxString buf; - buf.Printf("%s: %s\n\r", head->GetKeyString(), str->GetData()); +wxHTTP::wxHeaderConstIterator wxHTTP::FindHeader(const wxString& header) const +{ + wxHeaderConstIterator it = m_headers.begin(); + for ( wxHeaderConstIterator en = m_headers.end(); it != en; ++it ) + { + if ( header.CmpNoCase(it->first) == 0 ) + break; + } + + return it; +} - Write(buf, buf.Len()); +wxHTTP::wxCookieIterator wxHTTP::FindCookie(const wxString& cookie) +{ + wxCookieIterator it = m_cookies.begin(); + for ( wxCookieIterator en = m_cookies.end(); it != en; ++it ) + { + if ( cookie.CmpNoCase(it->first) == 0 ) + break; + } + + return it; +} - head = head->Next(); - } +wxHTTP::wxCookieConstIterator wxHTTP::FindCookie(const wxString& cookie) const +{ + wxCookieConstIterator it = m_cookies.begin(); + for ( wxCookieConstIterator en = m_cookies.end(); it != en; ++it ) + { + if ( cookie.CmpNoCase(it->first) == 0 ) + break; + } + + return it; } -bool wxHTTP::ParseHeaders() +void wxHTTP::SetHeader(const wxString& header, const wxString& h_data) { - wxString line; + if (m_read) { + ClearHeaders(); + m_read = false; + } + + wxHeaderIterator it = FindHeader(header); + if (it != m_headers.end()) + it->second = h_data; + else + m_headers[header] = h_data; +} - m_headers.Clear(); - m_read = TRUE; +wxString wxHTTP::GetHeader(const wxString& header) const +{ + wxHeaderConstIterator it = FindHeader(header); - while (1) { - m_error = GetLine(this, line); - if (m_error != wxPROTO_NOERR) - return FALSE; + return it == m_headers.end() ? wxGetEmptyString() : it->second; +} - if (line.Length() == 0) - break; +wxString wxHTTP::GetCookie(const wxString& cookie) const +{ + wxCookieConstIterator it = FindCookie(cookie); - printf("Header: %s\n", WXSTRINGCAST line); - int pos = line.Find(':'); - if (pos == -1) - return FALSE; + return it == m_cookies.end() ? wxGetEmptyString() : it->second; +} - wxString left_str = line(0, pos); - wxString right_str = line(pos+1, line.Length()); +wxString wxHTTP::GenerateAuthString(const wxString& user, const wxString& pass) const +{ + // TODO: Use wxBase64Encode() now that we have it instead of reproducing it - right_str = right_str.Strip(wxString::leading); + static const char *base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; - wxString *str = new wxString(right_str); + wxString buf; + wxString toencode; + + buf.Printf(wxT("Basic ")); + + toencode.Printf(wxT("%s:%s"),user.c_str(),pass.c_str()); + + size_t len = toencode.length(); + const wxChar *from = toencode.c_str(); + while (len >= 3) { // encode full blocks first + buf << wxString::Format(wxT("%c%c"), base64[(from[0] >> 2) & 0x3f], base64[((from[0] << 4) & 0x30) | ((from[1] >> 4) & 0xf)]); + buf << wxString::Format(wxT("%c%c"), base64[((from[1] << 2) & 0x3c) | ((from[2] >> 6) & 0x3)], base64[from[2] & 0x3f]); + from += 3; + len -= 3; + } + if (len > 0) { // pad the remaining characters + buf << wxString::Format(wxT("%c"), base64[(from[0] >> 2) & 0x3f]); + if (len == 1) { + buf << wxString::Format(wxT("%c="), base64[(from[0] << 4) & 0x30]); + } else { + buf << wxString::Format(wxT("%c%c"), base64[((from[0] << 4) & 0x30) | ((from[1] >> 4) & 0xf)], base64[(from[1] << 2) & 0x3c]); + } + buf << wxT("="); + } + + return buf; +} - m_headers.Append(left_str, (wxObject *) str); - } - return TRUE; +void wxHTTP::SetPostBuffer(const wxString& post_buf) +{ + // Use To8BitData() for backwards compatibility in this deprecated method. + // The new code should use the other overload or SetPostText() and specify + // the encoding to use for the text explicitly. + wxScopedCharBuffer scb = post_buf.To8BitData(); + if ( scb.length() ) + { + m_postBuffer.Clear(); + m_postBuffer.AppendData(scb.data(), scb.length()); + } } -bool wxHTTP::Connect(const wxString& host) +bool +wxHTTP::SetPostBuffer(const wxString& contentType, + const wxMemoryBuffer& data) { - wxIPV4address *addr; + m_postBuffer = data; + m_contentType = contentType; - if (m_connected) { - delete m_addr; - m_addr = NULL; - Close(); - } + return !m_postBuffer.IsEmpty(); +} - m_addr = addr = new wxIPV4address(); +bool +wxHTTP::SetPostText(const wxString& contentType, + const wxString& data, + const wxMBConv& conv) +{ +#if wxUSE_UNICODE + wxScopedCharBuffer scb = data.mb_str(conv); + const size_t len = scb.length(); + const char* const buf = scb.data(); +#else // !wxUSE_UNICODE + const size_t len = data.length(); + const char* const buf = data.mb_str(conv); +#endif // wxUSE_UNICODE/!wxUSE_UNICODE + + if ( !len ) + return false; + + m_postBuffer.Clear(); + m_postBuffer.AppendData(buf, len); + m_contentType = contentType; + + return true; +} - if (!addr->Hostname(host)) { - delete m_addr; - m_addr = NULL; - m_error = wxPROTO_NETERR; - return FALSE; - } +void wxHTTP::SendHeaders() +{ + typedef wxStringToStringHashMap::iterator iterator; + wxString buf; - if (!addr->Service("http")) - addr->Service(80); + for (iterator it = m_headers.begin(), en = m_headers.end(); it != en; ++it ) + { + buf.Printf(wxT("%s: %s\r\n"), it->first.c_str(), it->second.c_str()); + + const wxWX2MBbuf cbuf = buf.mb_str(); + Write(cbuf, strlen(cbuf)); + } +} - return TRUE; +bool wxHTTP::ParseHeaders() +{ + wxString line; + wxStringTokenizer tokenzr; + + ClearHeaders(); + ClearCookies(); + m_read = true; + + for ( ;; ) + { + m_lastError = ReadLine(this, line); + if (m_lastError != wxPROTO_NOERR) + return false; + + if ( line.empty() ) + break; + + wxString left_str = line.BeforeFirst(':'); + if(!left_str.CmpNoCase("Set-Cookie")) + { + wxString cookieName = line.AfterFirst(':').Strip(wxString::both).BeforeFirst('='); + wxString cookieValue = line.AfterFirst(':').Strip(wxString::both).AfterFirst('=').BeforeFirst(';'); + m_cookies[cookieName] = cookieValue; + + // For compatibility + m_headers[left_str] = line.AfterFirst(':').Strip(wxString::both); + } + else + { + m_headers[left_str] = line.AfterFirst(':').Strip(wxString::both); + } + } + return true; } -bool wxHTTP::Connect(wxSockAddress& addr, bool WXUNUSED(wait)) +bool wxHTTP::Connect(const wxString& host, unsigned short port) { - struct sockaddr *raw_addr; - size_t len; + wxIPV4address *addr; - m_addr = (wxSockAddress *)(addr.GetClassInfo()->CreateObject()); + if (m_addr) { + wxDELETE(m_addr); + Close(); + } - addr.Build(raw_addr, len); - m_addr->Disassemble(raw_addr, len); + m_addr = addr = new wxIPV4address(); - return TRUE; -} + if (!addr->Hostname(host)) { + wxDELETE(m_addr); + m_lastError = wxPROTO_NETERR; + return false; + } -bool wxHTTP::BuildRequest(const wxString& path, wxHTTP_Req req) -{ - char *tmp_buf; - char buf[HTTP_BSIZE]; - - switch (req) { - case wxHTTP_GET: - tmp_buf = "GET"; - break; - default: - return FALSE; - } - - SaveState(); - Notify(FALSE); - SetFlags(WAITALL); - - sprintf(buf, "%s %s HTTP/1.0\n\r", tmp_buf, (const char *)path); - Write(buf, strlen(buf)); - SendHeaders(); - sprintf(buf, "\n\r"); - Write(buf, strlen(buf)); - - wxString tmp_str; - - m_error = GetLine(this, tmp_str); - if (m_error != wxPROTO_NOERR) { - RestoreState(); - return FALSE; - } + if ( port ) + addr->Service(port); + else if (!addr->Service(wxT("http"))) + addr->Service(80); - if (!tmp_str.Contains("HTTP/")) { - // TODO: support HTTP v0.9 which can have no header. - SetHeader("Content-Length", "-1"); - SetHeader("Content-Type", "none/none"); - RestoreState(); - return TRUE; - } + wxString hostHdr = host; + if ( port && port != 80 ) + hostHdr << wxT(":") << port; + SetHeader(wxT("Host"), hostHdr); - wxStringTokenizer token(tmp_str,' '); - wxString tmp_str2; - bool ret_value; + m_lastError = wxPROTO_NOERR; + return true; +} - token.NextToken(); - tmp_str2 = token.NextToken(); +bool wxHTTP::Connect(const wxSockAddress& addr, bool WXUNUSED(wait)) +{ + if (m_addr) { + delete m_addr; + Close(); + } + + m_addr = addr.Clone(); + + wxIPV4address *ipv4addr = wxDynamicCast(&addr, wxIPV4address); + if ( ipv4addr ) + { + wxString hostHdr = ipv4addr->OrigHostname(); + unsigned short port = ipv4addr->Service(); + if ( port && port != 80 ) + hostHdr << wxT(":") << port; + SetHeader(wxT("Host"), hostHdr); + } + + m_lastError = wxPROTO_NOERR; + return true; +} - switch (atoi(tmp_str2)) { - case 200: - break; - default: - m_error = wxPROTO_NOFILE; +bool wxHTTP::BuildRequest(const wxString& path, const wxString& method) +{ + // Use the data in the post buffer, if any. + if ( !m_postBuffer.IsEmpty() ) + { + wxString len; + len << m_postBuffer.GetDataLen(); + + // Content length must be correct, so always set, possibly + // overriding the value set explicitly by a previous call to + // SetHeader("Content-Length"). + SetHeader(wxS("Content-Length"), len); + + // However if the user had explicitly set the content type, don't + // override it with the content type passed to SetPostText(). + if ( !m_contentType.empty() && GetContentType().empty() ) + SetHeader(wxS("Content-Type"), m_contentType); + } + + m_http_response = 0; + + // If there is no User-Agent defined, define it. + if ( GetHeader(wxT("User-Agent")).empty() ) + SetHeader(wxT("User-Agent"), wxT("wxWidgets 2.x")); + + // Send authentication information + if (!m_username.empty() || !m_password.empty()) { + SetHeader(wxT("Authorization"), GenerateAuthString(m_username, m_password)); + } + + SaveState(); + + // we may use non blocking sockets only if we can dispatch events from them + int flags = wxIsMainThread() && wxApp::IsMainLoopRunning() ? wxSOCKET_NONE + : wxSOCKET_BLOCK; + // and we must use wxSOCKET_WAITALL to ensure that all data is sent + flags |= wxSOCKET_WAITALL; + SetFlags(flags); + Notify(false); + + wxString buf; + buf.Printf(wxT("%s %s HTTP/1.0\r\n"), method, path); + const wxWX2MBbuf pathbuf = buf.mb_str(); + Write(pathbuf, strlen(pathbuf)); + SendHeaders(); + Write("\r\n", 2); + + if ( !m_postBuffer.IsEmpty() ) { + Write(m_postBuffer.GetData(), m_postBuffer.GetDataLen()); + + m_postBuffer.Clear(); + } + + wxString tmp_str; + m_lastError = ReadLine(this, tmp_str); + if (m_lastError != wxPROTO_NOERR) { + RestoreState(); + return false; + } + + if (!tmp_str.Contains(wxT("HTTP/"))) { + // TODO: support HTTP v0.9 which can have no header. + // FIXME: tmp_str is not put back in the in-queue of the socket. + m_lastError = wxPROTO_NOERR; + SetHeader(wxT("Content-Length"), wxT("-1")); + SetHeader(wxT("Content-Type"), wxT("none/none")); + RestoreState(); + return true; + } + + wxStringTokenizer token(tmp_str,wxT(' ')); + wxString tmp_str2; + bool ret_value; + + token.NextToken(); + tmp_str2 = token.NextToken(); + + m_http_response = wxAtoi(tmp_str2); + + switch ( tmp_str2[0u].GetValue() ) + { + case wxT('1'): + /* INFORMATION / SUCCESS */ + break; + + case wxT('2'): + /* SUCCESS */ + break; + + case wxT('3'): + /* REDIRECTION */ + break; + + default: + m_lastError = wxPROTO_NOFILE; + RestoreState(); + return false; + } + + m_lastError = wxPROTO_NOERR; + ret_value = ParseHeaders(); RestoreState(); - return FALSE; - } + return ret_value; +} - ret_value = ParseHeaders(); - RestoreState(); - return ret_value; +bool wxHTTP::Abort(void) +{ + return wxSocketClient::Close(); } -class wxHTTPStream : public wxSocketInputStream { +// ---------------------------------------------------------------------------- +// wxHTTPStream and wxHTTP::GetInputStream +// ---------------------------------------------------------------------------- + +class wxHTTPStream : public wxSocketInputStream +{ public: - wxHTTP *m_http; - size_t m_httpsize; + wxHTTP *m_http; + size_t m_httpsize; + unsigned long m_read_bytes; + + wxHTTPStream(wxHTTP *http) : wxSocketInputStream(*http) + { + m_http = http; + m_httpsize = 0; + m_read_bytes = 0; + } + + size_t GetSize() const { return m_httpsize; } + virtual ~wxHTTPStream(void) { m_http->Abort(); } + +protected: + size_t OnSysRead(void *buffer, size_t bufsize); - wxHTTPStream(wxHTTP *http) : wxSocketInputStream(*http), m_http(http) {} - size_t StreamSize() const { return m_httpsize; } - virtual ~wxHTTPStream(void) { m_http->Abort(); } + wxDECLARE_NO_COPY_CLASS(wxHTTPStream); }; -bool wxHTTP::Abort(void) +size_t wxHTTPStream::OnSysRead(void *buffer, size_t bufsize) { - return wxSocketClient::Close(); + if (m_read_bytes >= m_httpsize) + { + m_lasterror = wxSTREAM_EOF; + return 0; + } + + size_t ret = wxSocketInputStream::OnSysRead(buffer, bufsize); + m_read_bytes += ret; + + if (m_httpsize==(size_t)-1 && m_lasterror == wxSTREAM_READ_ERROR ) + { + // if m_httpsize is (size_t) -1 this means read until connection closed + // which is equivalent to getting a READ_ERROR, for clients however this + // must be translated into EOF, as it is the expected way of signalling + // end end of the content + m_lasterror = wxSTREAM_EOF; + } + + return ret; } wxInputStream *wxHTTP::GetInputStream(const wxString& path) { - wxHTTPStream *inp_stream = new wxHTTPStream(this); + wxHTTPStream *inp_stream; + + wxString new_path; + + m_lastError = wxPROTO_CONNERR; // all following returns share this type of error + if (!m_addr) + return NULL; - if (!m_addr || m_connected) { - m_error = wxPROTO_CONNERR; - return NULL; - } + // We set m_connected back to false so wxSocketBase will know what to do. +#ifdef __WXMAC__ + wxSocketClient::Connect(*m_addr , false ); + wxSocketClient::WaitOnConnect(10); + + if (!wxSocketClient::IsConnected()) + return NULL; +#else + if (!wxProtocol::Connect(*m_addr)) + return NULL; +#endif - if (!wxProtocol::Connect(*m_addr)) - return NULL; + // Use the user-specified method if any or determine the method to use + // automatically depending on whether we have anything to post or not. + wxString method = m_method; + if (method.empty()) + method = m_postBuffer.IsEmpty() ? wxS("GET"): wxS("POST"); - if (!BuildRequest(path, wxHTTP_GET)) - return NULL; + if (!BuildRequest(path, method)) + return NULL; - printf("Len = %s\n", WXSTRINGCAST GetHeader("Content-Length")); - if (!GetHeader("Content-Length").IsEmpty()) - inp_stream->m_httpsize = atoi(WXSTRINGCAST GetHeader("Content-Length")); + inp_stream = new wxHTTPStream(this); - return inp_stream; + if (!GetHeader(wxT("Content-Length")).empty()) + inp_stream->m_httpsize = wxAtoi(GetHeader(wxT("Content-Length"))); + else + inp_stream->m_httpsize = (size_t)-1; + + inp_stream->m_read_bytes = 0; + + Notify(false); + SetFlags(wxSOCKET_BLOCK | wxSOCKET_WAITALL); + + // no error; reset m_lastError + m_lastError = wxPROTO_NOERR; + return inp_stream; } -#endif - // wxUSE_SOCKETS +#endif // wxUSE_PROTOCOL_HTTP