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 Tiku
   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
  39
  40 #ifndef AMULE_DAEMON
  41 #include "inetdownload.h"       // Needed for inetDownload
  42 #include "muuli_wdr.h"          // Needed for ID_CANCEL: Let it here or will fail on win32
  43 #include "MuleGifCtrl.h"
  44
  45 typedef wxGauge wxGaugeControl;
  46
  47 DECLARE_LOCAL_EVENT_TYPE(wxEVT_HTTP_PROGRESS, wxANY_ID)
  48 DECLARE_LOCAL_EVENT_TYPE(wxEVT_HTTP_SHUTDOWN, wxANY_ID)
  49
  50
  51 class CHTTPDownloadDialog : public wxDialog
  52 {
  53 public:
  54         CHTTPDownloadDialog(CHTTPDownloadThread* thread)
  55           : wxDialog(wxTheApp->GetTopWindow(), -1, _("Downloading..."),
  56                         wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxSYSTEM_MENU)
  57         {
  58                 downloadDlg(this, true)->Show(this, true);
  59
  60                 m_progressbar = CastChild(ID_HTTPDOWNLOADPROGRESS, wxGaugeControl);
  61                 m_progressbar->SetRange(100);
  62
  63                 m_ani = CastChild(ID_ANIMATE, MuleGifCtrl);
  64                 m_ani->LoadData((const char*)inetDownload, sizeof(inetDownload));
  65                 m_ani->Start();
  66
  67                 m_thread = thread;
  68         }
  69
  70         ~CHTTPDownloadDialog() {
  71                 StopThread();
  72         }
  73
  74         void UpdateGauge(int total, int current) {
  75                 CFormat label(_("( %s / %s )"));
  76
  77                 label % CastItoXBytes(current);
  78                 if (total > 0) {
  79                         label % CastItoXBytes(total);
  80                 } else {
  81                         label % _("Unknown");
  82                 }
  83
  84                 CastChild(IDC_DOWNLOADSIZE, wxStaticText)->SetLabel(label.GetString());
  85
  86                 if (total && (total != m_progressbar->GetRange())) {
  87                         m_progressbar->SetRange(total);
  88                 }
  89
  90                 if (current && (current <= total)) {
  91                         m_progressbar->SetValue(current);
  92                 }
  93
  94                 Layout();
  95         }
  96
  97 private:
  98         void StopThread() {
  99                 if (m_thread) {
 100                         m_thread->Stop();
 101                         delete m_thread;
 102                         m_thread = NULL;
 103                 }
 104         }
 105
 106         void OnBtnCancel(wxCommandEvent& WXUNUSED(evt)) {
 107                 printf("HTTP download cancelled\n");
 108                 Show(false);
 109                 StopThread();
 110         }
 111
 112         void OnProgress(CMuleInternalEvent& evt) {
 113                 UpdateGauge(evt.GetExtraLong(), evt.GetInt());
 114         }
 115
 116         void OnShutdown(CMuleInternalEvent& WXUNUSED(evt)) {
 117                 Show(false);
 118                 Destroy();
 119         }
 120
 121         CMuleThread*    m_thread;
 122         MuleGifCtrl*    m_ani;
 123         wxGaugeControl* m_progressbar;
 124
 125         DECLARE_EVENT_TABLE()
 126 };
 127
 128
 129 BEGIN_EVENT_TABLE(CHTTPDownloadDialog, wxDialog)
 130         EVT_BUTTON(ID_HTTPCANCEL, CHTTPDownloadDialog::OnBtnCancel)
 131         EVT_MULE_INTERNAL(wxEVT_HTTP_PROGRESS, -1, CHTTPDownloadDialog::OnProgress)
 132         EVT_MULE_INTERNAL(wxEVT_HTTP_SHUTDOWN, -1, CHTTPDownloadDialog::OnShutdown)
 133 END_EVENT_TABLE()
 134
 135 DEFINE_LOCAL_EVENT_TYPE(wxEVT_HTTP_PROGRESS)
 136 DEFINE_LOCAL_EVENT_TYPE(wxEVT_HTTP_SHUTDOWN)
 137
 138 #endif
 139
 140
 141 CHTTPDownloadThread::CHTTPDownloadThread(const wxChar* url, const wxChar* filename, HTTP_Download_File file_id, bool showDialog)
 142 #ifdef AMULE_DAEMON
 143         : CMuleThread(wxTHREAD_DETACHED),
 144 #else
 145         : CMuleThread(showDialog ? wxTHREAD_JOINABLE : wxTHREAD_DETACHED),
 146 #endif
 147           m_url(url),
 148           m_tempfile(filename),
 149           m_result(-1),
 150           m_file_id(file_id),
 151           m_companion(NULL)
 152 {
 153         if (showDialog) {
 154 #ifndef AMULE_DAEMON
 155                 CHTTPDownloadDialog* dialog = new CHTTPDownloadDialog(this);
 156                 dialog->Show(true);
 157                 m_companion = dialog;
 158 #endif
 159         }
 160 }
 161
 162
 163 CMuleThread::ExitCode CHTTPDownloadThread::Entry()
 164 {
 165         if (TestDestroy()) {
 166                 return NULL;
 167         }
 168
 169         wxHTTP* url_handler = NULL;
 170         wxInputStream* url_read_stream = NULL;
 171
 172         printf("HTTP download thread started\n");
 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                 url_read_stream = GetInputStream(&url_handler, m_url, use_proxy);
 193
 194                 if (!url_read_stream) {
 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                 printf("Download size: %i\n",download_size);
 200
 201                 // Here is our read buffer
 202                 // <ken> Still, I'm sure 4092 is probably a better size.
 203                 const unsigned MAX_HTTP_READ = 4092;
 204
 205                 char buffer[MAX_HTTP_READ];
 206                 int current_read = 0;
 207                 int total_read = 0;
 208                 do {
 209                         url_read_stream->Read(buffer, MAX_HTTP_READ);
 210                         current_read = url_read_stream->LastRead();
 211                         if (current_read) {
 212                                 total_read += current_read;
 213                                 outfile.Write(buffer,current_read);
 214                                 int current_write = outfile.LastWrite();
 215                                 if (current_read != current_write) {
 216                                         throw wxString(wxT("Critical error while writing downloaded file"));
 217                                 } else if (m_companion) {
 218 #ifndef AMULE_DAEMON
 219                                         CMuleInternalEvent evt(wxEVT_HTTP_PROGRESS);
 220                                         evt.SetInt(total_read);
 221                                         evt.SetExtraLong(download_size);
 222                                         wxPostEvent(m_companion, evt);
 223 #endif
 224                                 }
 225                         }
 226                 } while (current_read && !TestDestroy());
 227
 228                 if (current_read == 0) {
 229                         // Download was succesful.
 230                         m_result = 1;
 231                 }
 232         } catch (const wxString& error) {
 233                 if (wxFileExists(m_tempfile)) {
 234                         wxRemoveFile(m_tempfile);
 235                 }
 236
 237                 AddLogLineM(false, error);
 238         }
 239
 240         delete url_read_stream;
 241         if (url_handler) {
 242                 url_handler->Destroy();
 243         }
 244
 245         printf("HTTP download thread ended\n");
 246
 247         return 0;
 248 }
 249
 250
 251 void CHTTPDownloadThread::OnExit()
 252 {
 253 #ifndef AMULE_DAEMON
 254         if (m_companion) {
 255                 CMuleInternalEvent termEvent(wxEVT_HTTP_SHUTDOWN);
 256                 wxPostEvent(m_companion, termEvent);
 257         }
 258 #endif
 259
 260         // Notice the app that the file finished download
 261         CMuleInternalEvent evt(wxEVT_CORE_FINISHED_HTTP_DOWNLOAD);
 262         evt.SetInt((int)m_file_id);
 263         evt.SetExtraLong((long)m_result);
 264         wxPostEvent(wxTheApp, evt);
 265 }
 266
 267
 268 //! This function's purpose is to handle redirections in a proper way.
 269 wxInputStream* CHTTPDownloadThread::GetInputStream(wxHTTP** url_handler, const wxString& location, bool proxy)
 270 {
 271         if (TestDestroy()) {
 272                 return NULL;
 273         }
 274
 275         if (!location.StartsWith(wxT("http://"))) {
 276                 // This is not a http url
 277                 throw wxString(wxT("Invalid URL for server.met download or http redirection (did you forget 'http://' ?)"));
 278         }
 279
 280         // Get the host
 281
 282         // Remove the "http://"
 283         wxString host = location.Right(location.Len() - 7); // strlen("http://") -> 7
 284
 285         // I belive this is a bug...
 286         // Sometimes "Location" header looks like this:
 287         // "http://www.whatever.com:8080http://www.whatever.com/downloads/something.zip"
 288         // So let's clean it...
 289
 290         int bad_url_pos = host.Find(wxT("http://"));
 291         wxString location_url;
 292         if (bad_url_pos != -1) {
 293                 // Malformed Location field on header (bug above?)
 294                 location_url = host.Mid(bad_url_pos);
 295                 host = host.Left(bad_url_pos);
 296                 // After the first '/' non-http-related, it's the location part of the URL
 297                 location_url = location_url.Right(location_url.Len() - 7).AfterFirst(wxT('/'));
 298         } else {
 299                 // Regular Location field
 300                 // After the first '/', it's the location part of the URL
 301                 location_url = host.AfterFirst(wxT('/'));
 302                 // The host is everything till the first "/"
 303                 host = host.BeforeFirst(wxT('/'));
 304         }
 305
 306         // Build the cleaned url now
 307         wxString url = wxT("http://") + host + wxT("/") + location_url;
 308
 309         int port = 80;
 310         if (host.Find(wxT(':')) != -1) {
 311                 // This http url has a port
 312                 port = wxAtoi(host.AfterFirst(wxT(':')));
 313                 host = host.BeforeFirst(wxT(':'));
 314         }
 315
 316         wxIPV4address addr;
 317         addr.Hostname(host);
 318         addr.Service(port);
 319         if (!(*url_handler)->Connect(addr, true)) {
 320                 throw wxString(wxT("Unable to connect to http download server"));
 321         }
 322
 323         wxInputStream* url_read_stream = (*url_handler)->GetInputStream(url);
 324
 325         printf("Host: %s:%i\n",(const char*)unicode2char(host),port);
 326         printf("URL: %s\n",(const char*)unicode2char(url));
 327         printf("Response: %i (Error: %i)\n",(*url_handler)->GetResponse(), (*url_handler)->GetError());
 328
 329         if (!(*url_handler)->GetResponse()) {
 330                 printf("WARNING: Void response on stream creation\n");
 331                 // WTF? Why does this happen?
 332                 // This is probably produced by an already existing connection, because
 333                 // the input stream is created nevertheless. However, data is not the same.
 334                 delete url_read_stream;
 335                 throw wxString(wxT("Invalid response from http download server"));
 336         }
 337
 338         if ((*url_handler)->GetResponse() == 301  // Moved permanently
 339                 || (*url_handler)->GetResponse() == 302 // Moved temporarily
 340                 // What about 300 (multiple choices)? Do we have to handle it?
 341                 ) {
 342
 343                 // We have to remove the current stream.
 344                 delete url_read_stream;
 345
 346                 wxString new_location = (*url_handler)->GetHeader(wxT("Location"));
 347
 348                 (*url_handler)->Destroy();
 349                 if (!new_location.IsEmpty()) {
 350                         (*url_handler) = new wxHTTP;
 351                         (*url_handler)->SetProxyMode(proxy);
 352                         url_read_stream = GetInputStream(url_handler, new_location, proxy);
 353                 } else {
 354                         printf("ERROR: Redirection code received with no URL\n");
 355                         url_handler = NULL;
 356                         url_read_stream = NULL;
 357                 }
 358         }
 359
 360         return url_read_stream;
 361 }
 362
 363 // File_checked_for_headers