src/HTTPDownload.cpp

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2003-2008 aMule Team ( admin@amule.org / http://www.amule.org )
   5 // Copyright (c) 2002-2008 Timo Kujala ( tiku@users.sourceforge.net )
   6 //
   7 // Any parts of this program derived from the xMule, lMule or eMule project,
   8 // or contributed by third-party developers are copyrighted by their
   9 // respective authors.
  10 //
  11 // This program is free software; you can redistribute it and/or modify
  12 // it under the terms of the GNU General Public License as published by
  13 // the Free Software Foundation; either version 2 of the License, or
  14 // (at your option) any later version.
  15 //
  16 // This program is distributed in the hope that it will be useful,
  17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 // GNU General Public License for more details.
  20 //
  21 // You should have received a copy of the GNU General Public License
  22 // along with this program; if not, write to the Free Software
  23 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  24 //
  25
  26
  27 #include <wx/wfstream.h>
  28 #include <wx/protocol/http.h>
  29
  30
  31 #include "HTTPDownload.h"                               // Interface declarations
  32 #include <common/StringFunctions.h>             // Needed for unicode2char
  33 #include "OtherFunctions.h"                             // Needed for CastChild
  34 #include "Logger.h"                                             // Needed for AddLogLine*
  35 #include <common/Format.h>                              // Needed for CFormat
  36 #include "InternalEvents.h"                             // Needed for CMuleInternalEvent
  37 #include "Preferences.h"
  38 #include "ScopedPtr.h"
  39
  40
  41 #ifndef AMULE_DAEMON
  42 #include "inetdownload.h"       // Needed for inetDownload
  43 #include "muuli_wdr.h"          // Needed for ID_CANCEL: Let it here or will fail on win32
  44 #include "MuleGifCtrl.h"
  45
  46 typedef wxGauge wxGaugeControl;
  47
  48 DECLARE_LOCAL_EVENT_TYPE(wxEVT_HTTP_PROGRESS, wxANY_ID)
  49 DECLARE_LOCAL_EVENT_TYPE(wxEVT_HTTP_SHUTDOWN, wxANY_ID)
  50
  51
  52 class CHTTPDownloadDialog : public wxDialog
  53 {
  54 public:
  55         CHTTPDownloadDialog(CHTTPDownloadThread* thread)
  56           : wxDialog(wxTheApp->GetTopWindow(), -1, _("Downloading..."),
  57                         wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxSYSTEM_MENU)
  58         {
  59                 downloadDlg(this, true)->Show(this, true);
  60
  61                 m_progressbar = CastChild(ID_HTTPDOWNLOADPROGRESS, wxGaugeControl);
  62                 m_progressbar->SetRange(100);
  63
  64                 m_ani = CastChild(ID_ANIMATE, MuleGifCtrl);
  65                 m_ani->LoadData((const char*)inetDownload, sizeof(inetDownload));
  66                 m_ani->Start();
  67
  68                 m_thread = thread;
  69         }
  70
  71         ~CHTTPDownloadDialog() {
  72                 StopThread();
  73         }
  74
  75         void UpdateGauge(int total, int current) {
  76                 CFormat label(_("( %s / %s )"));
  77
  78                 label % CastItoXBytes(current);
  79                 if (total > 0) {
  80                         label % CastItoXBytes(total);
  81                 } else {
  82                         label % _("Unknown");
  83                 }
  84
  85                 CastChild(IDC_DOWNLOADSIZE, wxStaticText)->SetLabel(label.GetString());
  86
  87                 if (total && (total != m_progressbar->GetRange())) {
  88                         m_progressbar->SetRange(total);
  89                 }
  90
  91                 if (current && (current <= total)) {
  92                         m_progressbar->SetValue(current);
  93                 }
  94
  95                 Layout();
  96         }
  97
  98 private:
  99         void StopThread() {
 100                 if (m_thread) {
 101                         m_thread->Stop();
 102                         delete m_thread;
 103                         m_thread = NULL;
 104                 }
 105         }
 106
 107         void OnBtnCancel(wxCommandEvent& WXUNUSED(evt)) {
 108                 AddLogLineNS(_("HTTP download cancelled"));
 109                 Show(false);
 110                 StopThread();
 111         }
 112
 113         void OnProgress(CMuleInternalEvent& evt) {
 114                 UpdateGauge(evt.GetExtraLong(), evt.GetInt());
 115         }
 116
 117         void OnShutdown(CMuleInternalEvent& WXUNUSED(evt)) {
 118                 Show(false);
 119                 Destroy();
 120         }
 121
 122         CMuleThread*    m_thread;
 123         MuleGifCtrl*    m_ani;
 124         wxGaugeControl* m_progressbar;
 125
 126         DECLARE_EVENT_TABLE()
 127 };
 128
 129
 130 BEGIN_EVENT_TABLE(CHTTPDownloadDialog, wxDialog)
 131         EVT_BUTTON(ID_HTTPCANCEL, CHTTPDownloadDialog::OnBtnCancel)
 132         EVT_MULE_INTERNAL(wxEVT_HTTP_PROGRESS, -1, CHTTPDownloadDialog::OnProgress)
 133         EVT_MULE_INTERNAL(wxEVT_HTTP_SHUTDOWN, -1, CHTTPDownloadDialog::OnShutdown)
 134 END_EVENT_TABLE()
 135
 136 DEFINE_LOCAL_EVENT_TYPE(wxEVT_HTTP_PROGRESS)
 137 DEFINE_LOCAL_EVENT_TYPE(wxEVT_HTTP_SHUTDOWN)
 138
 139 #endif
 140
 141
 142 CHTTPDownloadThread::CHTTPDownloadThread(const wxChar* url, const wxChar* filename, HTTP_Download_File file_id, bool showDialog)
 143 #ifdef AMULE_DAEMON
 144         : CMuleThread(wxTHREAD_DETACHED),
 145 #else
 146         : CMuleThread(showDialog ? wxTHREAD_JOINABLE : wxTHREAD_DETACHED),
 147 #endif
 148           m_url(url),
 149           m_tempfile(filename),
 150           m_result(-1),
 151           m_file_id(file_id),
 152           m_companion(NULL)
 153 {
 154         if (showDialog) {
 155 #ifndef AMULE_DAEMON
 156                 CHTTPDownloadDialog* dialog = new CHTTPDownloadDialog(this);
 157                 dialog->Show(true);
 158                 m_companion = dialog;
 159 #endif
 160         }
 161 }
 162
 163
 164 CMuleThread::ExitCode CHTTPDownloadThread::Entry()
 165 {
 166         if (TestDestroy()) {
 167                 return NULL;
 168         }
 169
 170         wxHTTP* url_handler = NULL;
 171
 172         AddLogLineNS(_("HTTP download thread started"));
 173
 174         const CProxyData* proxy_data = thePrefs::GetProxyData();
 175         bool use_proxy = proxy_data != NULL && proxy_data->m_proxyEnable;
 176
 177         try {
 178                 wxFFileOutputStream outfile(m_tempfile);
 179
 180                 if (!outfile.Ok()) {
 181                         throw wxString(CFormat(wxT("Unable to create destination file %s for download!\n")) % m_tempfile);
 182                 }
 183
 184                 if ( m_url.IsEmpty() ) {
 185                         // Nowhere to download from!
 186                         throw wxString(wxT("The URL to download can't be empty\n"));
 187                 }
 188
 189                 url_handler = new wxHTTP;
 190                 url_handler->SetProxyMode(use_proxy);
 191
 192                 CScopedPtr<wxInputStream> url_read_stream(GetInputStream(&url_handler, m_url, use_proxy));
 193
 194                 if (!url_read_stream.get()) {
 195                         throw wxString(CFormat(wxT("The URL %s returned: %i - Error (%i)!")) % m_url % url_handler->GetResponse() % url_handler->GetError());
 196                 }
 197
 198                 int download_size = url_read_stream->GetSize();
 199                 AddLogLineNS(CFormat(_("Download size: %i")) % download_size);
 200
 201                 // Here is our read buffer
 202                 // <ken> Still, I'm sure 4092 is probably a better size.
 203                 // MP: Most people can download at least at 32kb/s from http...
 204                 const unsigned MAX_HTTP_READ = 32768;
 205
 206                 char buffer[MAX_HTTP_READ];
 207                 int current_read = 0;
 208                 int total_read = 0;
 209                 do {
 210                         url_read_stream->Read(buffer, MAX_HTTP_READ);
 211                         current_read = url_read_stream->LastRead();
 212                         if (current_read) {
 213                                 total_read += current_read;
 214                                 outfile.Write(buffer,current_read);
 215                                 int current_write = outfile.LastWrite();
 216                                 if (current_read != current_write) {
 217                                         throw wxString(wxT("Critical error while writing downloaded file"));
 218                                 } else if (m_companion) {
 219 #ifndef AMULE_DAEMON
 220                                         CMuleInternalEvent evt(wxEVT_HTTP_PROGRESS);
 221                                         evt.SetInt(total_read);
 222                                         evt.SetExtraLong(download_size);
 223                                         wxPostEvent(m_companion, evt);
 224 #endif
 225                                 }
 226                         }
 227                 } while (current_read && !TestDestroy());
 228
 229                 if (current_read == 0) {
 230                         if (total_read != download_size) {
 231                                 throw wxString(CFormat(_("Expected %d bytes, but downloaded %d bytes")) % download_size % total_read);
 232                         } else {
 233                                 // Download was succesful.
 234                                 m_result = 1;
 235                         }
 236                 }
 237         } catch (const wxString& error) {
 238                 if (wxFileExists(m_tempfile)) {
 239                         wxRemoveFile(m_tempfile);
 240                 }
 241
 242                 AddLogLineNS(error); // If there's console output anyway there should also be console output on error.
 243         }
 244
 245         if (url_handler) {
 246                 url_handler->Destroy();
 247         }
 248
 249         AddLogLineNS(_("HTTP download thread ended"));
 250
 251         return 0;
 252 }
 253
 254
 255 void CHTTPDownloadThread::OnExit()
 256 {
 257 #ifndef AMULE_DAEMON
 258         if (m_companion) {
 259                 CMuleInternalEvent termEvent(wxEVT_HTTP_SHUTDOWN);
 260                 wxPostEvent(m_companion, termEvent);
 261         }
 262 #endif
 263
 264         // Notice the app that the file finished download
 265         CMuleInternalEvent evt(wxEVT_CORE_FINISHED_HTTP_DOWNLOAD);
 266         evt.SetInt((int)m_file_id);
 267         evt.SetExtraLong((long)m_result);
 268         wxPostEvent(wxTheApp, evt);
 269 }
 270
 271
 272 //! This function's purpose is to handle redirections in a proper way.
 273 wxInputStream* CHTTPDownloadThread::GetInputStream(wxHTTP** url_handler, const wxString& location, bool proxy)
 274 {
 275         if (TestDestroy()) {
 276                 return NULL;
 277         }
 278
 279         if (!location.StartsWith(wxT("http://"))) {
 280                 // This is not a http url
 281                 throw wxString(wxT("Invalid URL for http download or http redirection (did you forget 'http://' ?)"));
 282         }
 283
 284         // Get the host
 285
 286         // Remove the "http://"
 287         wxString host = location.Right(location.Len() - 7); // strlen("http://") -> 7
 288
 289         // I belive this is a bug...
 290         // Sometimes "Location" header looks like this:
 291         // "http://www.whatever.com:8080http://www.whatever.com/downloads/something.zip"
 292         // So let's clean it...
 293
 294         int bad_url_pos = host.Find(wxT("http://"));
 295         wxString location_url;
 296         if (bad_url_pos != -1) {
 297                 // Malformed Location field on header (bug above?)
 298                 location_url = host.Mid(bad_url_pos);
 299                 host = host.Left(bad_url_pos);
 300                 // After the first '/' non-http-related, it's the location part of the URL
 301                 location_url = location_url.Right(location_url.Len() - 7).AfterFirst(wxT('/'));
 302         } else {
 303                 // Regular Location field
 304                 // After the first '/', it's the location part of the URL
 305                 location_url = host.AfterFirst(wxT('/'));
 306                 // The host is everything till the first "/"
 307                 host = host.BeforeFirst(wxT('/'));
 308         }
 309
 310         // Build the cleaned url now
 311         wxString url = wxT("http://") + host + wxT("/") + location_url;
 312
 313         int port = 80;
 314         if (host.Find(wxT(':')) != -1) {
 315                 // This http url has a port
 316                 port = wxAtoi(host.AfterFirst(wxT(':')));
 317                 host = host.BeforeFirst(wxT(':'));
 318         }
 319
 320         wxIPV4address addr;
 321         addr.Hostname(host);
 322         addr.Service(port);
 323         if (!(*url_handler)->Connect(addr, true)) {
 324                 throw wxString(wxT("Unable to connect to http download server"));
 325         }
 326
 327         wxInputStream* url_read_stream = (*url_handler)->GetInputStream(url);
 328
 329         AddLogLineNS(CFormat(_("Host: %s:%i\n")) % host % port);
 330         AddLogLineNS(CFormat(wxT("URL: %s\n")) % url);
 331         AddLogLineNS(CFormat(_("Response: %i (Error: %i)")) % (*url_handler)->GetResponse() % (*url_handler)->GetError());
 332
 333         if (!(*url_handler)->GetResponse()) {
 334                 AddLogLineNS(_("WARNING: Void response on stream creation"));
 335                 // WTF? Why does this happen?
 336                 // This is probably produced by an already existing connection, because
 337                 // the input stream is created nevertheless. However, data is not the same.
 338                 delete url_read_stream;
 339                 throw wxString(wxT("Invalid response from http download server"));
 340         }
 341
 342         if ((*url_handler)->GetResponse() == 301  // Moved permanently
 343                 || (*url_handler)->GetResponse() == 302 // Moved temporarily
 344                 // What about 300 (multiple choices)? Do we have to handle it?
 345                 ) {
 346
 347                 // We have to remove the current stream.
 348                 delete url_read_stream;
 349
 350                 wxString new_location = (*url_handler)->GetHeader(wxT("Location"));
 351
 352                 (*url_handler)->Destroy();
 353                 if (!new_location.IsEmpty()) {
 354                         (*url_handler) = new wxHTTP;
 355                         (*url_handler)->SetProxyMode(proxy);
 356                         url_read_stream = GetInputStream(url_handler, new_location, proxy);
 357                 } else {
 358                         AddLogLineCS(_("ERROR: Redirection code received with no URL"));
 359                         url_handler = NULL;
 360                         url_read_stream = NULL;
 361                 }
 362         }
 363
 364         return url_read_stream;
 365 }
 366
 367 // File_checked_for_headers