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