src/inetfile/inetgetfile.cpp

   1  /*
   2  * $Logfile: /Freespace2/code/Inetfile/inetgetfile.cpp $
   3  * $Revision$
   4  * $Date$
   5  * $Author$
   6  *
   7  * InternetGetFile Class
   8  *
   9  * $Log$
  10  * Revision 1.2  2002/05/07 03:16:45  theoddone33
  11  * The Great Newline Fix
  12  *
  13  * Revision 1.1.1.1  2002/05/03 03:28:09  root
  14  * Initial import.
  15  *
  16  *
  17  * 4     8/22/99 1:19p Dave
  18  * Fixed up http proxy code. Cleaned up scoring code. Reverse the order in
  19  * which d3d cards are detected.
  20  *
  21  * 3     6/16/99 10:27a Andsager
  22  * Make directory if it does not already exist.
  23  *
  24  * 2     4/20/99 6:39p Dave
  25  * Almost done with artillery targeting. Added support for downloading
  26  * images on the PXO screen.
  27  *
  28  * 1     4/20/99 4:37p Dave
  29  *
  30  * Initial version
  31  *
  32  * $NoKeywords: $
  33  */
  34
  35 #include <windows.h>
  36 #include <stdio.h>
  37 #include <direct.h>
  38 #include "cftp.h"
  39 #include "chttpget.h"
  40
  41 #include "inetgetfile.h"
  42
  43 #define INET_STATE_CONNECTING           1
  44 #define INET_STATE_ERROR                        2
  45 #define INET_STATE_RECEIVING            3
  46 #define INET_STATE_GOT_FILE             4
  47
  48 void InetGetFile::AbortGet()
  49 {
  50         if(m_bUseHTTP)
  51         {
  52                 http->AbortGet();
  53         }
  54         else
  55         {
  56                 ftp->AbortGet();
  57         }
  58 }
  59
  60 InetGetFile::InetGetFile(char *URL,char *localfile)
  61 {
  62         m_HardError = 0;
  63         http=NULL;
  64         ftp=NULL;
  65         if ((URL==NULL)||(localfile==NULL)) {
  66                 m_HardError = INET_ERROR_BADPARMS;
  67         }
  68
  69         // create directory if not already there.
  70         char dir_name[256], *end;
  71
  72         // make sure localfile has \ in it or we'll be here a long time.
  73         if (strstr(localfile, "\\")) {
  74                 strcpy(dir_name, localfile);
  75                 int len = strlen(localfile);
  76                 end = dir_name + len;
  77
  78                 // start from end of localfile and go to first \ to get dirname
  79                 while ( *end != '\\' ) {
  80                         end--;
  81                 }
  82                 *end = '\0';
  83
  84                 if ( _mkdir(dir_name)==0 )      {
  85                         mprintf(( "CFILE: Created new directory '%s'\n", dir_name ));
  86                 }
  87         }
  88
  89         if (strstr(URL,"http:")) {
  90                 m_bUseHTTP = TRUE;
  91
  92                 // using http proxy?
  93                 extern char Multi_options_proxy[512];
  94                 extern ushort Multi_options_proxy_port;
  95                 if(strlen(Multi_options_proxy) > 0){
  96                         http = new ChttpGet(URL, localfile, Multi_options_proxy, Multi_options_proxy_port);
  97                 } else {
  98                         http = new ChttpGet(URL, localfile);
  99                 }
 100
 101                 if (http==NULL) {
 102                         m_HardError = INET_ERROR_NO_MEMORY;
 103                 }
 104         } else if (strstr(URL,"ftp:")) {
 105                 m_bUseHTTP = FALSE;
 106                 ftp = new CFtpGet(URL,localfile);
 107                 if (ftp==NULL) {
 108                         m_HardError = INET_ERROR_NO_MEMORY;
 109                 }
 110         } else {
 111                 m_HardError = INET_ERROR_CANT_PARSE_URL;
 112         }
 113         Sleep(1000);
 114 }
 115
 116 InetGetFile::~InetGetFile()
 117 {
 118         if(http!=NULL) delete http;
 119         if(ftp!=NULL) delete ftp;
 120 }
 121
 122 BOOL InetGetFile::IsConnecting()
 123 {
 124         int state;
 125         if(m_bUseHTTP)
 126         {
 127                 state = http->GetStatus();
 128         }
 129         else
 130         {
 131                 state = ftp->GetStatus();
 132         }
 133         if(state == FTP_STATE_CONNECTING)
 134         {
 135                 return TRUE;
 136         }
 137         else
 138         {
 139                 return FALSE;
 140         }
 141
 142 }
 143
 144 BOOL InetGetFile::IsReceiving()
 145 {
 146         int state;
 147         if(m_bUseHTTP)
 148         {
 149                 state = http->GetStatus();
 150         }
 151         else
 152         {
 153                 state = ftp->GetStatus();
 154         }
 155         if(state == FTP_STATE_RECEIVING)
 156         {
 157                 return TRUE;
 158         }
 159         else
 160         {
 161                 return FALSE;
 162         }
 163 }
 164
 165 BOOL InetGetFile::IsFileReceived()
 166 {
 167         int state;
 168         if(m_bUseHTTP)
 169         {
 170                 state = http->GetStatus();
 171         }
 172         else
 173         {
 174                 state = ftp->GetStatus();
 175         }
 176         if(state == FTP_STATE_FILE_RECEIVED)
 177         {
 178                 return TRUE;
 179         }
 180         else
 181         {
 182                 return FALSE;
 183         }
 184 }
 185
 186 BOOL InetGetFile::IsFileError()
 187 {
 188         int state;
 189         if(m_HardError) return TRUE;
 190         if(m_bUseHTTP)
 191         {
 192                 state = http->GetStatus();
 193         }
 194         else
 195         {
 196                 state = ftp->GetStatus();
 197         }
 198         switch(state)
 199         {
 200
 201         case FTP_STATE_URL_PARSING_ERROR:
 202         case FTP_STATE_HOST_NOT_FOUND:
 203         case FTP_STATE_DIRECTORY_INVALID:
 204         case FTP_STATE_FILE_NOT_FOUND:
 205         case FTP_STATE_CANT_CONNECT:
 206         case FTP_STATE_LOGIN_ERROR:
 207         case FTP_STATE_INTERNAL_ERROR:
 208         case FTP_STATE_SOCKET_ERROR:
 209         case FTP_STATE_UNKNOWN_ERROR:
 210         case FTP_STATE_RECV_FAILED:
 211         case FTP_STATE_CANT_WRITE_FILE:
 212                 return TRUE;
 213         case FTP_STATE_CONNECTING:
 214                 return FALSE;
 215         default:
 216                 return FALSE;
 217         }
 218 }
 219
 220 int InetGetFile::GetErrorCode()
 221 {
 222         int state;
 223         if(m_HardError) return m_HardError;
 224         if(m_bUseHTTP)
 225         {
 226                 state = http->GetStatus();
 227         }
 228         else
 229         {
 230                 state = ftp->GetStatus();
 231         }
 232         switch(state)
 233         {
 234
 235         case FTP_STATE_URL_PARSING_ERROR:
 236                 return INET_ERROR_CANT_PARSE_URL;
 237
 238         case FTP_STATE_HOST_NOT_FOUND:
 239                 return INET_ERROR_HOST_NOT_FOUND;
 240
 241
 242         case FTP_STATE_DIRECTORY_INVALID:
 243         case FTP_STATE_FILE_NOT_FOUND:
 244                 return INET_ERROR_BAD_FILE_OR_DIR;
 245
 246         case FTP_STATE_CANT_CONNECT:
 247         case FTP_STATE_LOGIN_ERROR:
 248         case FTP_STATE_INTERNAL_ERROR:
 249         case FTP_STATE_SOCKET_ERROR:
 250         case FTP_STATE_UNKNOWN_ERROR:
 251         case FTP_STATE_RECV_FAILED:
 252
 253                 return INET_ERROR_UNKNOWN_ERROR;
 254
 255         case FTP_STATE_CANT_WRITE_FILE:
 256                 return INET_ERROR_CANT_WRITE_FILE;
 257         default:
 258                 return INET_ERROR_NO_ERROR;
 259         }
 260 }
 261
 262 int InetGetFile::GetTotalBytes()
 263 {
 264         if(m_bUseHTTP)
 265         {
 266                 return http->GetTotalBytes();
 267         }
 268         else
 269         {
 270                 return ftp->GetTotalBytes();
 271         }
 272 }
 273
 274 int InetGetFile::GetBytesIn()
 275 {
 276         if(m_bUseHTTP)
 277         {
 278                 return http->GetBytesIn();
 279         }
 280         else
 281         {
 282                 return ftp->GetBytesIn();
 283         }
 284 }