/////////////////////////////////////////////////////////////////////////////
-// Name: ftp.cpp
+// Name: common/ftp.cpp
// Purpose: FTP protocol
// Author: Guilhem Lavaux
// Modified by: Mark Johnson, wxWindows@mj10777.de
// Vadim Zeitlin (numerous fixes and rewrites to all part of the
// code, support ASCII/Binary modes, better error reporting, more
// robust Abort(), support for arbitrary FTP commands, ...)
+// Randall Fox (support for active mode)
// Created: 07/07/1997
// RCS-ID: $Id$
// Copyright: (c) 1997, 1998 Guilhem Lavaux
+// (c) 1998-2004 wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// declarations
// ============================================================================
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
- #pragma implementation "ftp.h"
-#endif
-
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "wx/utils.h"
#include "wx/log.h"
#include "wx/intl.h"
+ #include "wx/wxcrtvararg.h"
#endif // WX_PRECOMP
#include "wx/sckaddr.h"
// ----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxFTP, wxProtocol)
-IMPLEMENT_PROTOCOL(wxFTP, wxT("ftp"), wxT("ftp"), TRUE)
+IMPLEMENT_PROTOCOL(wxFTP, wxT("ftp"), wxT("ftp"), true)
// ============================================================================
// implementation
wxFTP::wxFTP()
{
m_lastError = wxPROTO_NOERR;
- m_streaming = FALSE;
+ m_streaming = false;
m_currentTransfermode = NONE;
m_user = wxT("anonymous");
m_passwd << wxGetUserId() << wxT('@') << wxGetFullHostName();
SetNotify(0);
- SetFlags(wxSOCKET_NONE);
+ SetFlags(wxSOCKET_NOWAIT);
+ m_bPassive = true;
+ SetDefaultTimeout(60); // Default is Sixty Seconds
+ m_bEncounteredError = false;
}
wxFTP::~wxFTP()
{
if ( m_streaming )
{
+ // if we are streaming, this will issue
+ // an FTP ABORT command, to tell the server we are aborting
(void)Abort();
}
+ // now this issues a "QUIT" command to tell the server we are
Close();
}
if ( !wxProtocol::Connect(addr) )
{
m_lastError = wxPROTO_NETERR;
- return FALSE;
+ return false;
}
if ( !m_user )
{
m_lastError = wxPROTO_CONNERR;
- return FALSE;
+ return false;
}
// we should have 220 welcome message
if ( !CheckResult('2') )
{
Close();
- return FALSE;
+ return false;
}
wxString command;
if ( rc == '2' )
{
// 230 return: user accepted without password
- return TRUE;
+ return true;
}
if ( rc != '3' )
{
Close();
- return FALSE;
+ return false;
}
command.Printf(wxT("PASS %s"), m_passwd.c_str());
if ( !CheckCommand(command, '2') )
{
Close();
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
bool wxFTP::Connect(const wxString& host)
if ( m_streaming )
{
m_lastError = wxPROTO_STREAMING;
- return FALSE;
+ return false;
}
if ( IsConnected() )
char wxFTP::GetResult()
{
+ // if we've already had a read or write timeout error, the connection is
+ // probably toast, so don't bother, it just wastes the users time
+ if ( m_bEncounteredError )
+ return 0;
+
wxString code;
// m_lastResult will contain the entire server response, possibly on
// ...
// xyz ...
// and the intermeidate lines may start with xyz or not
- bool badReply = FALSE;
- bool firstLine = TRUE;
- bool endOfReply = FALSE;
+ bool badReply = false;
+ bool firstLine = true;
+ bool endOfReply = false;
while ( !endOfReply && !badReply )
{
wxString line;
- m_lastError = ReadLine(line);
+ m_lastError = ReadLine(this,line);
if ( m_lastError )
+ {
+ m_bEncounteredError = true;
return 0;
+ }
if ( !m_lastResult.empty() )
{
{
if ( firstLine )
{
- badReply = TRUE;
+ badReply = true;
}
else
{
switch ( chMarker )
{
case _T(' '):
- endOfReply = TRUE;
+ endOfReply = true;
break;
case _T('-'):
- firstLine = FALSE;
+ firstLine = false;
break;
default:
// unexpected
- badReply = TRUE;
+ badReply = true;
}
}
else // subsequent line of multiline reply
{
- if ( wxStrncmp(line, code, LEN_CODE) == 0 )
+ if ( line.compare(0, LEN_CODE, code) == 0 )
{
if ( chMarker == _T(' ') )
{
- endOfReply = TRUE;
+ endOfReply = true;
}
wxLogTrace(FTP_TRACE_MASK, _T("<== %s %s"),
}
// if we got here we must have a non empty code string
- return code[0u];
+ return (char)code[0u];
}
// ----------------------------------------------------------------------------
if ( transferMode == m_currentTransfermode )
{
// nothing to do
- return TRUE;
+ return true;
}
wxString mode;
if ( !DoSimpleCommand(_T("TYPE"), mode) )
{
- wxLogError(_("Failed to set FTP transfer mode to %s."), (const wxChar*)
+ wxLogError(_("Failed to set FTP transfer mode to %s."),
(transferMode == ASCII ? _("ASCII") : _("binary")));
- return FALSE;
+ return false;
}
- // If we get here the operation has been succesfully completed
+ // If we get here the operation has been successfully completed
// Set the status-member
m_currentTransfermode = transferMode;
- return TRUE;
+ return true;
}
bool wxFTP::DoSimpleCommand(const wxChar *command, const wxString& arg)
{
wxLogDebug(_T("FTP command '%s' failed."), fullcmd.c_str());
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
bool wxFTP::ChDir(const wxString& dir)
if ( CheckCommand(wxT("PWD"), '2') )
{
// the result is at least that long if CheckCommand() succeeded
- const wxChar *p = m_lastResult.c_str() + LEN_CODE + 1;
+ wxString::const_iterator p = m_lastResult.begin() + LEN_CODE + 1;
if ( *p != _T('"') )
{
- wxLogDebug(_T("Missing starting quote in reply for PWD: %s"), p);
+ wxLogDebug(_T("Missing starting quote in reply for PWD: %s"),
+ wxString(p, m_lastResult.end()));
}
else
{
- for ( p++; *p; p++ )
+ for ( ++p; (bool)*p; ++p ) // FIXME-DMARS
{
if ( *p == _T('"') )
{
// check if the quote is doubled
- p++;
+ ++p;
if ( !*p || *p != _T('"') )
{
// no, this is the end
str = wxT("RNFR ") + src;
if ( !CheckCommand(str, '3') )
- return FALSE;
+ return false;
str = wxT("RNTO ") + dst;
: wxSocketInputStream(*sock)
{
m_ftp = ftp;
-
- // FIXME make the timeout configurable
-
- // set a shorter than default timeout
- m_i_socket->SetTimeout(60); // 1 minute
+ // socket timeout automatically set in GetPort function
}
- size_t GetSize() const { return m_ftpsize; }
-
virtual ~wxInputFTPStream()
{
- delete m_i_socket;
+ delete m_i_socket; // keep at top
- if ( IsOk() )
- {
- // wait for "226 transfer completed"
- m_ftp->CheckResult('2');
+ // when checking the result, the stream will
+ // almost always show an error, even if the file was
+ // properly transfered, thus, lets just grab the result
- m_ftp->m_streaming = FALSE;
+ // we are looking for "226 transfer completed"
+ char code = m_ftp->GetResult();
+ if ('2' == code)
+ {
+ // it was a good transfer.
+ // we're done!
+ m_ftp->m_streaming = false;
+ return;
}
- else
+ // did we timeout?
+ if (0 == code)
{
+ // the connection is probably toast. issue an abort, and
+ // then a close. there won't be any more waiting
+ // for this connection
m_ftp->Abort();
+ m_ftp->Close();
+ return;
}
-
- // delete m_i_socket; // moved to top of destructor to accomodate wu-FTPd >= 2.6.0
+ // There was a problem with the transfer and the server
+ // has acknowledged it. If we issue an "ABORT" now, the user
+ // would get the "226" for the abort and think the xfer was
+ // complete, thus, don't do anything here, just return
}
wxFTP *m_ftp;
- size_t m_ftpsize;
DECLARE_NO_COPY_CLASS(wxInputFTPStream)
};
delete m_o_socket;
// read this reply
- m_ftp->CheckResult('2');
+ m_ftp->GetResult(); // save result so user can get to it
- m_ftp->m_streaming = FALSE;
+ m_ftp->m_streaming = false;
}
else
{
DECLARE_NO_COPY_CLASS(wxOutputFTPStream)
};
-wxSocketClient *wxFTP::GetPort()
+void wxFTP::SetDefaultTimeout(wxUint32 Value)
{
- int a[6];
+ m_uiDefaultTimeout = Value;
+ SetTimeout(Value); // sets it for this socket
+}
- if ( !DoSimpleCommand(_T("PASV")) )
- {
- wxLogError(_("The FTP server doesn't support passive mode."));
+wxSocketBase *wxFTP::GetPort()
+{
+ /*
+ PASSIVE: Client sends a "PASV" to the server. The server responds with
+ an address and port number which it will be listening on. Then
+ the client connects to the server at the specified address and
+ port.
+
+ ACTIVE: Client sends the server a PORT command which includes an
+ address and port number which the client will be listening on.
+ The server then connects to the client at that address and
+ port.
+ */
+
+ wxSocketBase *socket = m_bPassive ? GetPassivePort() : GetActivePort();
+ if ( !socket )
+ {
+ m_bEncounteredError = true;
return NULL;
}
- const wxChar *addrStart = wxStrchr(m_lastResult, _T('('));
- if ( !addrStart )
+ // Now set the time for the new socket to the default or user selected
+ // timeout period
+ socket->SetTimeout(m_uiDefaultTimeout);
+
+ return socket;
+}
+
+wxSocketBase *wxFTP::AcceptIfActive(wxSocketBase *sock)
+{
+ if ( m_bPassive )
+ return sock;
+
+ // now wait for a connection from server
+ wxSocketServer *sockSrv = (wxSocketServer *)sock;
+ if ( !sockSrv->WaitForAccept() )
{
- m_lastError = wxPROTO_PROTERR;
+ m_lastError = wxPROTO_CONNERR;
+ wxLogError(_("Timeout while waiting for FTP server to connect, try passive mode."));
+ delete sock;
+ sock = NULL;
+ }
+ else
+ {
+ sock = sockSrv->Accept(true);
+ delete sockSrv;
+ }
+
+ return sock;
+}
+
+wxString wxFTP::GetPortCmdArgument(const wxIPV4address& addrLocal,
+ const wxIPV4address& addrNew)
+{
+ // Just fills in the return value with the local IP
+ // address of the current socket. Also it fill in the
+ // PORT which the client will be listening on
+
+ wxString addrIP = addrLocal.IPAddress();
+ int portNew = addrNew.Service();
+
+ // We need to break the PORT number in bytes
+ addrIP.Replace(_T("."), _T(","));
+ addrIP << _T(',')
+ << wxString::Format(_T("%d"), portNew >> 8) << _T(',')
+ << wxString::Format(_T("%d"), portNew & 0xff);
+
+ // Now we have a value like "10,0,0,1,5,23"
+ return addrIP;
+}
+wxSocketBase *wxFTP::GetActivePort()
+{
+ // we need an address to listen on
+ wxIPV4address addrNew, addrLocal;
+ GetLocal(addrLocal);
+ addrNew.AnyAddress();
+ addrNew.Service(0); // pick an open port number.
+
+ wxSocketServer *sockSrv = new wxSocketServer(addrNew);
+ if (!sockSrv->Ok())
+ {
+ // We use Ok() here to see if everything is ok
+ m_lastError = wxPROTO_PROTERR;
+ delete sockSrv;
return NULL;
}
- const wxChar *addrEnd = wxStrchr(addrStart, _T(')'));
- if ( !addrEnd )
+ //gets the new address, actually it is just the port number
+ sockSrv->GetLocal(addrNew);
+
+ // Now we create the argument of the PORT command, we send in both
+ // addresses because the addrNew has an IP of "0.0.0.0", so we need the
+ // value in addrLocal
+ wxString port = GetPortCmdArgument(addrLocal, addrNew);
+ if ( !DoSimpleCommand(_T("PORT "), port) )
{
m_lastError = wxPROTO_PROTERR;
+ delete sockSrv;
+ wxLogError(_("The FTP server doesn't support the PORT command."));
+ return NULL;
+ }
+ sockSrv->Notify(false); // Don't send any events
+ return sockSrv;
+}
+
+wxSocketBase *wxFTP::GetPassivePort()
+{
+ if ( !DoSimpleCommand(_T("PASV")) )
+ {
+ wxLogError(_("The FTP server doesn't support passive mode."));
return NULL;
}
- wxString straddr(addrStart + 1, addrEnd);
+ size_t addrStart = m_lastResult.find(_T('('));
+ size_t addrEnd = (addrStart == wxString::npos)
+ ? wxString::npos
+ : m_lastResult.find(_T(')'), addrStart);
+ if ( addrEnd == wxString::npos )
+ {
+ m_lastError = wxPROTO_PROTERR;
+ return NULL;
+ }
+
+ // get the port number and address
+ int a[6];
+ wxString straddr(m_lastResult, addrStart + 1, addrEnd - (addrStart + 1));
wxSscanf(straddr, wxT("%d,%d,%d,%d,%d,%d"),
&a[2],&a[3],&a[4],&a[5],&a[0],&a[1]);
- wxUint32 hostaddr = (wxUint16)a[5] << 24 |
- (wxUint16)a[4] << 16 |
- (wxUint16)a[3] << 8 |
- a[2];
- wxUint16 port = (wxUint16)a[0] << 8 | a[1];
+ wxUint32 hostaddr = (wxUint16)a[2] << 24 |
+ (wxUint16)a[3] << 16 |
+ (wxUint16)a[4] << 8 |
+ a[5];
+ wxUint16 port = (wxUint16)(a[0] << 8 | a[1]);
wxIPV4address addr;
addr.Hostname(hostaddr);
return NULL;
}
- client->Notify(FALSE);
+ client->Notify(false);
return client;
}
bool wxFTP::Abort()
{
if ( !m_streaming )
- return TRUE;
+ return true;
- m_streaming = FALSE;
+ m_streaming = false;
if ( !CheckCommand(wxT("ABOR"), '4') )
- return FALSE;
+ return false;
return CheckResult('2');
}
wxInputStream *wxFTP::GetInputStream(const wxString& path)
{
- int pos_size;
- wxInputFTPStream *in_stream;
-
if ( ( m_currentTransfermode == NONE ) && !SetTransferMode(BINARY) )
return NULL;
- wxSocketClient *sock = GetPort();
+ wxSocketBase *sock = GetPort();
if ( !sock )
{
return NULL;
}
- wxString tmp_str = wxT("RETR ") + wxURL::ConvertFromURI(path);
+ wxString tmp_str = wxT("RETR ") + wxURI::Unescape(path);
if ( !CheckCommand(tmp_str, '1') )
return NULL;
- m_streaming = TRUE;
-
- in_stream = new wxInputFTPStream(this, sock);
+ sock = AcceptIfActive(sock);
+ if ( !sock )
+ return NULL;
- pos_size = m_lastResult.Index(wxT('('));
- if ( pos_size != wxNOT_FOUND )
- {
- wxString str_size = m_lastResult(pos_size+1, m_lastResult.Index(wxT(')'))-1);
+ sock->SetFlags(wxSOCKET_WAITALL);
- in_stream->m_ftpsize = wxAtoi(WXSTRINGCAST str_size);
- }
+ m_streaming = true;
- sock->SetFlags(wxSOCKET_WAITALL);
+ wxInputFTPStream *in_stream = new wxInputFTPStream(this, sock);
return in_stream;
}
if ( ( m_currentTransfermode == NONE ) && !SetTransferMode(BINARY) )
return NULL;
- wxSocketClient *sock = GetPort();
+ wxSocketBase *sock = GetPort();
wxString tmp_str = wxT("STOR ") + path;
if ( !CheckCommand(tmp_str, '1') )
return NULL;
- m_streaming = TRUE;
+ sock = AcceptIfActive(sock);
+
+ m_streaming = true;
return new wxOutputFTPStream(this, sock);
}
{
wxSocketBase *sock = GetPort();
if (!sock)
- return FALSE;
+ return false;
// NLST : List of Filenames (including Directory's !)
// LIST : depending on BS of FTP-Server
// - Windows : like "dir" command
// - others : ?
wxString line(details ? _T("LIST") : _T("NLST"));
- if ( !!wildcard )
+ if ( !wildcard.empty() )
{
line << _T(' ') << wildcard;
}
- if (!CheckCommand(line, '1'))
+ if ( !CheckCommand(line, '1') )
{
- return FALSE;
+ m_lastError = wxPROTO_PROTERR;
+ wxLogDebug(_T("FTP 'LIST' command returned unexpected result from server"));
+ delete sock;
+ return false;
}
+
+ sock = AcceptIfActive(sock);
+ if ( !sock )
+ return false;
+
files.Empty();
- while ( ReadLine(sock, line) == wxPROTO_NOERR )
+ while (ReadLine(sock, line) == wxPROTO_NOERR )
{
files.Add(line);
}
+
delete sock;
// the file list should be terminated by "226 Transfer complete""
- if ( !CheckResult('2') )
- return FALSE;
-
- return TRUE;
+ return CheckResult('2');
}
bool wxFTP::FileExists(const wxString& fileName)
// current dir. It does so by simply doing an NLST (via GetList).
// If this succeeds (and the list is not empty) the file exists.
- bool retval = FALSE;
+ bool retval = false;
wxArrayString fileList;
- if ( GetList(fileList, fileName, FALSE) )
+ if ( GetList(fileList, fileName, false) )
{
// Some ftp-servers (Ipswitch WS_FTP Server 1.0.5 does this)
- // displays this behaviour when queried on a non-existing file:
+ // displays this behaviour when queried on a nonexistent file:
// NLST this_file_does_not_exist
// 150 Opening ASCII data connection for directory listing
// (no data transferred)
&statuscode, &filesize) == 2 )
{
// We've gotten a good reply.
- ok = TRUE;
+ ok = true;
}
else
{
// Something bad happened.. A "2yz" reply with no size
// Fallback
- ok = FALSE;
+ ok = false;
}
}
// We now try to get details for the file with a "LIST"-command
// and then parse the output from there..
wxArrayString fileList;
- if ( GetList(fileList, fileName, TRUE) )
+ if ( GetList(fileList, fileName, true) )
{
if ( !fileList.IsEmpty() )
{
// substring containing the name we are looking for. We
// stop the iteration at the first occurrence of the
// filename. The search is not case-sensitive.
- bool foundIt = FALSE;
+ bool foundIt = false;
size_t i;
- for ( i = 0; !foundIt && i < fileList.Count(); i++ )
+ for ( i = 0; !foundIt && i < fileList.GetCount(); i++ )
{
foundIt = fileList[i].Upper().Contains(fileName.Upper());
}
projects / wxWidgets.git / blobdiff