src/inetfile/inetgetfile.cpp

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