src/common/http.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/http.cpp
   3 // Purpose:     HTTP protocol
   4 // Author:      Guilhem Lavaux
   5 // Modified by: Simo Virokannas (authentication, Dec 2005)
   6 // Created:     August 1997
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1997, 1998 Guilhem Lavaux
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifdef __BORLANDC__
  16     #pragma hdrstop
  17 #endif
  18
  19 #if wxUSE_PROTOCOL_HTTP
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23
  24 #ifndef WX_PRECOMP
  25     #include "wx/string.h"
  26     #include "wx/app.h"
  27 #endif
  28
  29 #include "wx/tokenzr.h"
  30 #include "wx/socket.h"
  31 #include "wx/protocol/protocol.h"
  32 #include "wx/url.h"
  33 #include "wx/protocol/http.h"
  34 #include "wx/sckstrm.h"
  35 #include "wx/thread.h"
  36
  37 IMPLEMENT_DYNAMIC_CLASS(wxHTTP, wxProtocol)
  38 IMPLEMENT_PROTOCOL(wxHTTP, wxT("http"), wxT("80"), true)
  39
  40 wxHTTP::wxHTTP()
  41   : wxProtocol()
  42 {
  43     m_addr = NULL;
  44     m_read = false;
  45     m_proxy_mode = false;
  46     m_post_buf = wxEmptyString;
  47     m_http_response = 0;
  48
  49     SetNotify(wxSOCKET_LOST_FLAG);
  50 }
  51
  52 wxHTTP::~wxHTTP()
  53 {
  54     ClearHeaders();
  55
  56     delete m_addr;
  57 }
  58
  59 void wxHTTP::ClearHeaders()
  60 {
  61   m_headers.clear();
  62 }
  63
  64 wxString wxHTTP::GetContentType()
  65 {
  66     return GetHeader(wxT("Content-Type"));
  67 }
  68
  69 void wxHTTP::SetProxyMode(bool on)
  70 {
  71     m_proxy_mode = on;
  72 }
  73
  74 wxHTTP::wxHeaderIterator wxHTTP::FindHeader(const wxString& header)
  75 {
  76     wxHeaderIterator it = m_headers.begin();
  77     for ( wxHeaderIterator en = m_headers.end(); it != en; ++it )
  78     {
  79         if ( header.CmpNoCase(it->first) == 0 )
  80             break;
  81     }
  82
  83     return it;
  84 }
  85
  86 wxHTTP::wxHeaderConstIterator wxHTTP::FindHeader(const wxString& header) const
  87 {
  88     wxHeaderConstIterator it = m_headers.begin();
  89     for ( wxHeaderConstIterator en = m_headers.end(); it != en; ++it )
  90     {
  91         if ( header.CmpNoCase(it->first) == 0 )
  92             break;
  93     }
  94
  95     return it;
  96 }
  97
  98 void wxHTTP::SetHeader(const wxString& header, const wxString& h_data)
  99 {
 100     if (m_read) {
 101         ClearHeaders();
 102         m_read = false;
 103     }
 104
 105     wxHeaderIterator it = FindHeader(header);
 106     if (it != m_headers.end())
 107         it->second = h_data;
 108     else
 109         m_headers[header] = h_data;
 110 }
 111
 112 wxString wxHTTP::GetHeader(const wxString& header) const
 113 {
 114     wxHeaderConstIterator it = FindHeader(header);
 115
 116     return it == m_headers.end() ? wxGetEmptyString() : it->second;
 117 }
 118
 119 wxString wxHTTP::GenerateAuthString(const wxString& user, const wxString& pass) const
 120 {
 121     static const char *base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 122
 123     wxString buf;
 124     wxString toencode;
 125
 126     buf.Printf(wxT("Basic "));
 127
 128     toencode.Printf(wxT("%s:%s"),user.c_str(),pass.c_str());
 129
 130     size_t len = toencode.length();
 131     const wxChar *from = toencode.c_str();
 132     while (len >= 3) { // encode full blocks first
 133         buf << wxString::Format(wxT("%c%c"), base64[(from[0] >> 2) & 0x3f], base64[((from[0] << 4) & 0x30) | ((from[1] >> 4) & 0xf)]);
 134         buf << wxString::Format(wxT("%c%c"), base64[((from[1] << 2) & 0x3c) | ((from[2] >> 6) & 0x3)], base64[from[2] & 0x3f]);
 135         from += 3;
 136         len -= 3;
 137     }
 138     if (len > 0) { // pad the remaining characters
 139         buf << wxString::Format(wxT("%c"), base64[(from[0] >> 2) & 0x3f]);
 140         if (len == 1) {
 141             buf << wxString::Format(wxT("%c="), base64[(from[0] << 4) & 0x30]);
 142         } else {
 143             buf << wxString::Format(wxT("%c%c"), base64[((from[0] << 4) & 0x30) | ((from[1] >> 4) & 0xf)], base64[(from[1] << 2) & 0x3c]);
 144         }
 145         buf << wxT("=");
 146     }
 147
 148     return buf;
 149 }
 150
 151 void wxHTTP::SetPostBuffer(const wxString& post_buf)
 152 {
 153     m_post_buf = post_buf;
 154 }
 155
 156 void wxHTTP::SendHeaders()
 157 {
 158     typedef wxStringToStringHashMap::iterator iterator;
 159     wxString buf;
 160
 161     for (iterator it = m_headers.begin(), en = m_headers.end(); it != en; ++it )
 162     {
 163         buf.Printf(wxT("%s: %s\r\n"), it->first.c_str(), it->second.c_str());
 164
 165         const wxWX2MBbuf cbuf = buf.mb_str();
 166         Write(cbuf, strlen(cbuf));
 167     }
 168 }
 169
 170 bool wxHTTP::ParseHeaders()
 171 {
 172     wxString line;
 173     wxStringTokenizer tokenzr;
 174
 175     ClearHeaders();
 176     m_read = true;
 177
 178     for ( ;; )
 179     {
 180         m_perr = ReadLine(this, line);
 181         if (m_perr != wxPROTO_NOERR)
 182             return false;
 183
 184         if (line.length() == 0)
 185             break;
 186
 187         wxString left_str = line.BeforeFirst(':');
 188         m_headers[left_str] = line.AfterFirst(':').Strip(wxString::both);
 189     }
 190     return true;
 191 }
 192
 193 bool wxHTTP::Connect(const wxString& host, unsigned short port)
 194 {
 195     wxIPV4address *addr;
 196
 197     if (m_addr) {
 198         delete m_addr;
 199         m_addr = NULL;
 200         Close();
 201     }
 202
 203     m_addr = addr = new wxIPV4address();
 204
 205     if (!addr->Hostname(host)) {
 206         delete m_addr;
 207         m_addr = NULL;
 208         m_perr = wxPROTO_NETERR;
 209         return false;
 210     }
 211
 212     if ( port )
 213         addr->Service(port);
 214     else if (!addr->Service(wxT("http")))
 215         addr->Service(80);
 216
 217     SetHeader(wxT("Host"), host);
 218
 219     return true;
 220 }
 221
 222 bool wxHTTP::Connect(const wxSockAddress& addr, bool WXUNUSED(wait))
 223 {
 224     if (m_addr) {
 225         delete m_addr;
 226         Close();
 227     }
 228
 229     m_addr = addr.Clone();
 230
 231     wxIPV4address *ipv4addr = wxDynamicCast(&addr, wxIPV4address);
 232     if (ipv4addr)
 233         SetHeader(wxT("Host"), ipv4addr->OrigHostname());
 234
 235     return true;
 236 }
 237
 238 bool wxHTTP::BuildRequest(const wxString& path, wxHTTP_Req req)
 239 {
 240     const wxChar *request;
 241
 242     switch (req)
 243     {
 244         case wxHTTP_GET:
 245             request = wxT("GET");
 246             break;
 247
 248         case wxHTTP_POST:
 249             request = wxT("POST");
 250             if ( GetHeader( wxT("Content-Length") ).IsNull() )
 251                 SetHeader( wxT("Content-Length"), wxString::Format( wxT("%lu"), (unsigned long)m_post_buf.Len() ) );
 252             break;
 253
 254         default:
 255             return false;
 256     }
 257
 258     m_http_response = 0;
 259
 260     // If there is no User-Agent defined, define it.
 261     if (GetHeader(wxT("User-Agent")).IsNull())
 262         SetHeader(wxT("User-Agent"), wxT("wxWidgets 2.x"));
 263
 264     // Send authentication information
 265     if (!m_username.empty() || !m_password.empty()) {
 266         SetHeader(wxT("Authorization"), GenerateAuthString(m_username, m_password));
 267     }
 268
 269     SaveState();
 270
 271     // we may use non blocking sockets only if we can dispatch events from them
 272     SetFlags( wxIsMainThread() && wxApp::IsMainLoopRunning() ? wxSOCKET_NONE
 273                                                              : wxSOCKET_BLOCK );
 274     Notify(false);
 275
 276     wxString buf;
 277     buf.Printf(wxT("%s %s HTTP/1.0\r\n"), request, path.c_str());
 278     const wxWX2MBbuf pathbuf = buf.mb_str();
 279     Write(pathbuf, strlen(pathbuf));
 280     SendHeaders();
 281     Write("\r\n", 2);
 282
 283     if ( req == wxHTTP_POST ) {
 284         Write(m_post_buf.mbc_str(), m_post_buf.Len());
 285         m_post_buf = wxEmptyString;
 286     }
 287
 288     wxString tmp_str;
 289     m_perr = ReadLine(this, tmp_str);
 290     if (m_perr != wxPROTO_NOERR) {
 291         RestoreState();
 292         return false;
 293     }
 294
 295     if (!tmp_str.Contains(wxT("HTTP/"))) {
 296         // TODO: support HTTP v0.9 which can have no header.
 297         // FIXME: tmp_str is not put back in the in-queue of the socket.
 298         SetHeader(wxT("Content-Length"), wxT("-1"));
 299         SetHeader(wxT("Content-Type"), wxT("none/none"));
 300         RestoreState();
 301         return true;
 302     }
 303
 304     wxStringTokenizer token(tmp_str,wxT(' '));
 305     wxString tmp_str2;
 306     bool ret_value;
 307
 308     token.NextToken();
 309     tmp_str2 = token.NextToken();
 310
 311     m_http_response = wxAtoi(tmp_str2);
 312
 313     switch ( tmp_str2[0u].GetValue() )
 314     {
 315         case wxT('1'):
 316             /* INFORMATION / SUCCESS */
 317             break;
 318
 319         case wxT('2'):
 320             /* SUCCESS */
 321             break;
 322
 323         case wxT('3'):
 324             /* REDIRECTION */
 325             break;
 326
 327         default:
 328             m_perr = wxPROTO_NOFILE;
 329             RestoreState();
 330             return false;
 331     }
 332
 333     ret_value = ParseHeaders();
 334     RestoreState();
 335     return ret_value;
 336 }
 337
 338 class wxHTTPStream : public wxSocketInputStream
 339 {
 340 public:
 341     wxHTTP *m_http;
 342     size_t m_httpsize;
 343     unsigned long m_read_bytes;
 344
 345     wxHTTPStream(wxHTTP *http) : wxSocketInputStream(*http), m_http(http) {}
 346     size_t GetSize() const { return m_httpsize; }
 347     virtual ~wxHTTPStream(void) { m_http->Abort(); }
 348
 349 protected:
 350     size_t OnSysRead(void *buffer, size_t bufsize);
 351
 352     DECLARE_NO_COPY_CLASS(wxHTTPStream)
 353 };
 354
 355 size_t wxHTTPStream::OnSysRead(void *buffer, size_t bufsize)
 356 {
 357     if (m_httpsize > 0 && m_read_bytes >= m_httpsize)
 358     {
 359         m_lasterror = wxSTREAM_EOF;
 360         return 0;
 361     }
 362
 363     size_t ret = wxSocketInputStream::OnSysRead(buffer, bufsize);
 364     m_read_bytes += ret;
 365
 366     if (m_httpsize==(size_t)-1 && m_lasterror == wxSTREAM_READ_ERROR )
 367     {
 368         // if m_httpsize is (size_t) -1 this means read until connection closed
 369         // which is equivalent to getting a READ_ERROR, for clients however this
 370         // must be translated into EOF, as it is the expected way of signalling
 371         // end end of the content
 372         m_lasterror = wxSTREAM_EOF ;
 373     }
 374
 375     return ret;
 376 }
 377
 378 bool wxHTTP::Abort(void)
 379 {
 380     return wxSocketClient::Close();
 381 }
 382
 383 wxInputStream *wxHTTP::GetInputStream(const wxString& path)
 384 {
 385     wxHTTPStream *inp_stream;
 386
 387     wxString new_path;
 388
 389     m_perr = wxPROTO_CONNERR;
 390     if (!m_addr)
 391         return NULL;
 392
 393     // We set m_connected back to false so wxSocketBase will know what to do.
 394 #ifdef __WXMAC__
 395     wxSocketClient::Connect(*m_addr , false );
 396     wxSocketClient::WaitOnConnect(10);
 397
 398     if (!wxSocketClient::IsConnected())
 399         return NULL;
 400 #else
 401     if (!wxProtocol::Connect(*m_addr))
 402         return NULL;
 403 #endif
 404
 405     if (!BuildRequest(path, m_post_buf.empty() ? wxHTTP_GET : wxHTTP_POST))
 406         return NULL;
 407
 408     inp_stream = new wxHTTPStream(this);
 409
 410     if (!GetHeader(wxT("Content-Length")).empty())
 411         inp_stream->m_httpsize = wxAtoi(GetHeader(wxT("Content-Length")));
 412     else
 413         inp_stream->m_httpsize = (size_t)-1;
 414
 415     inp_stream->m_read_bytes = 0;
 416
 417     Notify(false);
 418     SetFlags(wxSOCKET_BLOCK | wxSOCKET_WAITALL);
 419
 420     return inp_stream;
 421 }
 422
 423 #endif // wxUSE_PROTOCOL_HTTP