wxFTP::wxFTP()
{
- m_lastError = wxPROTO_NOERR;
m_streaming = false;
m_currentTransfermode = NONE;
- m_user = wxT("anonymous");
- m_passwd << wxGetUserId() << wxT('@') << wxGetFullHostName();
+ m_username = wxT("anonymous");
+ m_password << wxGetUserId() << wxT('@') << wxGetFullHostName();
SetNotify(0);
SetFlags(wxSOCKET_NOWAIT);
m_bPassive = true;
- SetDefaultTimeout(60); // Default is Sixty Seconds
m_bEncounteredError = false;
}
// wxFTP connect and login methods
// ----------------------------------------------------------------------------
-bool wxFTP::Connect(wxSockAddress& addr, bool WXUNUSED(wait))
+bool wxFTP::Connect(const wxSockAddress& addr, bool WXUNUSED(wait))
{
if ( !wxProtocol::Connect(addr) )
{
return false;
}
- if ( !m_user )
+ if ( !m_username )
{
m_lastError = wxPROTO_CONNERR;
return false;
}
wxString command;
- command.Printf(wxT("USER %s"), m_user.c_str());
+ command.Printf(wxT("USER %s"), m_username.c_str());
char rc = SendCommand(command);
if ( rc == '2' )
{
// 230 return: user accepted without password
+ m_lastError = wxPROTO_NOERR;
return true;
}
if ( rc != '3' )
{
+ m_lastError = wxPROTO_CONNERR;
Close();
return false;
}
- command.Printf(wxT("PASS %s"), m_passwd.c_str());
+ command.Printf(wxT("PASS %s"), m_password.c_str());
if ( !CheckCommand(command, '2') )
{
+ m_lastError = wxPROTO_CONNERR;
Close();
return false;
}
+ m_lastError = wxPROTO_NOERR;
return true;
}
{
if ( !CheckCommand(wxT("QUIT"), '2') )
{
- wxLogDebug(_T("Failed to close connection gracefully."));
+ m_lastError = wxPROTO_CONNERR;
+ wxLogDebug(wxT("Failed to close connection gracefully."));
}
}
// low level methods
// ============================================================================
+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_CONNERR;
+ wxLogError(_("Timeout while waiting for FTP server to connect, try passive mode."));
+ delete sock;
+ sock = NULL;
+ }
+ else
+ {
+ m_lastError = wxPROTO_NOERR;
+ sock = sockSrv->Accept(true);
+ delete sockSrv;
+ }
+
+ return sock;
+}
+
+bool wxFTP::Abort()
+{
+ if ( !m_streaming )
+ return true;
+
+ m_streaming = false;
+ if ( !CheckCommand(wxT("ABOR"), '4') )
+ return false;
+
+ return CheckResult('2');
+}
+
+
// ----------------------------------------------------------------------------
// Send command to FTP server
// ----------------------------------------------------------------------------
return 0;
}
-#ifdef __WXDEBUG__
// don't show the passwords in the logs (even in debug ones)
wxString cmd, password;
- if ( command.Upper().StartsWith(_T("PASS "), &password) )
+ if ( command.Upper().StartsWith(wxT("PASS "), &password) )
{
- cmd << _T("PASS ") << wxString(_T('*'), password.length());
+ cmd << wxT("PASS ") << wxString(wxT('*'), password.length());
}
else
{
cmd = command;
}
- wxLogTrace(FTP_TRACE_MASK, _T("==> %s"), cmd.c_str());
-#endif // __WXDEBUG__
+ LogRequest(cmd);
+ m_lastError = wxPROTO_NOERR;
return GetResult();
}
// ----------------------------------------------------------------------------
-// Recieve servers reply
+// Receive servers reply
// ----------------------------------------------------------------------------
char wxFTP::GetResult()
return 0;
}
+ LogResponse(line);
+
if ( !m_lastResult.empty() )
{
// separate from last line
- m_lastResult += _T('\n');
+ m_lastResult += wxT('\n');
}
m_lastResult += line;
{
badReply = true;
}
- else
- {
- wxLogTrace(FTP_TRACE_MASK, _T("<== %s %s"),
- code.c_str(), line.c_str());
- }
}
else // line has at least 4 chars
{
if ( firstLine )
{
code = wxString(line, LEN_CODE);
- wxLogTrace(FTP_TRACE_MASK, _T("<== %s %s"),
- code.c_str(), line.c_str() + LEN_CODE + 1);
switch ( chMarker )
{
- case _T(' '):
+ case wxT(' '):
endOfReply = true;
break;
- case _T('-'):
+ case wxT('-'):
firstLine = false;
break;
{
if ( line.compare(0, LEN_CODE, code) == 0 )
{
- if ( chMarker == _T(' ') )
+ if ( chMarker == wxT(' ') )
{
endOfReply = true;
}
-
- wxLogTrace(FTP_TRACE_MASK, _T("<== %s %s"),
- code.c_str(), line.c_str() + LEN_CODE + 1);
- }
- else
- {
- // just part of reply
- wxLogTrace(FTP_TRACE_MASK, _T("<== %s %s"),
- code.c_str(), line.c_str());
}
}
}
if ( badReply )
{
- wxLogDebug(_T("Broken FTP server: '%s' is not a valid reply."),
+ wxLogDebug(wxT("Broken FTP server: '%s' is not a valid reply."),
m_lastResult.c_str());
m_lastError = wxPROTO_PROTERR;
return 0;
}
+ else
+ m_lastError = wxPROTO_NOERR;
// if we got here we must have a non empty code string
return (char)code[0u];
switch ( transferMode )
{
default:
- wxFAIL_MSG(_T("unknown FTP transfer mode"));
+ wxFAIL_MSG(wxT("unknown FTP transfer mode"));
// fall through
case BINARY:
- mode = _T('I');
+ mode = wxT('I');
break;
case ASCII:
- mode = _T('A');
+ mode = wxT('A');
break;
}
- if ( !DoSimpleCommand(_T("TYPE"), mode) )
+ if ( !DoSimpleCommand(wxT("TYPE"), mode) )
{
wxLogError(_("Failed to set FTP transfer mode to %s."),
(transferMode == ASCII ? _("ASCII") : _("binary")));
wxString fullcmd = command;
if ( !arg.empty() )
{
- fullcmd << _T(' ') << arg;
+ fullcmd << wxT(' ') << arg;
}
if ( !CheckCommand(fullcmd, '2') )
{
- wxLogDebug(_T("FTP command '%s' failed."), fullcmd.c_str());
+ wxLogDebug(wxT("FTP command '%s' failed."), fullcmd.c_str());
+ m_lastError = wxPROTO_NETERR;
return false;
}
+ m_lastError = wxPROTO_NOERR;
return true;
}
// tree conventions, but they always understand CDUP - should we use it if
// dir == ".."? OTOH, do such servers (still) exist?
- return DoSimpleCommand(_T("CWD"), dir);
+ return DoSimpleCommand(wxT("CWD"), dir);
}
bool wxFTP::MkDir(const wxString& dir)
{
- return DoSimpleCommand(_T("MKD"), dir);
+ return DoSimpleCommand(wxT("MKD"), dir);
}
bool wxFTP::RmDir(const wxString& dir)
{
- return DoSimpleCommand(_T("RMD"), dir);
+ return DoSimpleCommand(wxT("RMD"), dir);
}
wxString wxFTP::Pwd()
{
// the result is at least that long if CheckCommand() succeeded
wxString::const_iterator p = m_lastResult.begin() + LEN_CODE + 1;
- if ( *p != _T('"') )
+ if ( *p != wxT('"') )
{
- wxLogDebug(_T("Missing starting quote in reply for PWD: %s"),
+ wxLogDebug(wxT("Missing starting quote in reply for PWD: %s"),
wxString(p, m_lastResult.end()));
}
else
{
for ( ++p; (bool)*p; ++p ) // FIXME-DMARS
{
- if ( *p == _T('"') )
+ if ( *p == wxT('"') )
{
// check if the quote is doubled
++p;
- if ( !*p || *p != _T('"') )
+ if ( !*p || *p != wxT('"') )
{
// no, this is the end
break;
if ( !*p )
{
- wxLogDebug(_T("Missing ending quote in reply for PWD: %s"),
+ wxLogDebug(wxT("Missing ending quote in reply for PWD: %s"),
m_lastResult.c_str() + LEN_CODE + 1);
}
}
}
else
{
- wxLogDebug(_T("FTP PWD command failed."));
+ m_lastError = wxPROTO_PROTERR;
+ wxLogDebug(wxT("FTP PWD command failed."));
}
return path;
}
// ----------------------------------------------------------------------------
-// wxFTP download and upload
+// wxFTP port methods
// ----------------------------------------------------------------------------
-class wxInputFTPStream : public wxSocketInputStream
-{
-public:
- wxInputFTPStream(wxFTP *ftp, wxSocketBase *sock)
- : wxSocketInputStream(*sock)
- {
- m_ftp = ftp;
- // socket timeout automatically set in GetPort function
- }
-
- virtual ~wxInputFTPStream()
- {
- delete m_i_socket; // keep at top
-
- // 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
-
- // 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;
- }
- // 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;
- }
- // 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;
-
- DECLARE_NO_COPY_CLASS(wxInputFTPStream)
-};
-
-class wxOutputFTPStream : public wxSocketOutputStream
-{
-public:
- wxOutputFTPStream(wxFTP *ftp_clt, wxSocketBase *sock)
- : wxSocketOutputStream(*sock), m_ftp(ftp_clt)
- {
- }
-
- virtual ~wxOutputFTPStream(void)
- {
- if ( IsOk() )
- {
- // close data connection first, this will generate "transfer
- // completed" reply
- delete m_o_socket;
-
- // read this reply
- m_ftp->GetResult(); // save result so user can get to it
-
- m_ftp->m_streaming = false;
- }
- else
- {
- // abort data connection first
- m_ftp->Abort();
-
- // and close it after
- delete m_o_socket;
- }
- }
-
- wxFTP *m_ftp;
-
- DECLARE_NO_COPY_CLASS(wxOutputFTPStream)
-};
-
-void wxFTP::SetDefaultTimeout(wxUint32 Value)
-{
- m_uiDefaultTimeout = Value;
- SetTimeout(Value); // sets it for this socket
-}
-
-
wxSocketBase *wxFTP::GetPort()
{
/*
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_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)
{
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);
+ addrIP.Replace(wxT("."), wxT(","));
+ addrIP << wxT(',')
+ << wxString::Format(wxT("%d"), portNew >> 8) << wxT(',')
+ << wxString::Format(wxT("%d"), portNew & 0xff);
// Now we have a value like "10,0,0,1,5,23"
return addrIP;
// 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) )
+ if ( !DoSimpleCommand(wxT("PORT"), port) )
{
m_lastError = wxPROTO_PROTERR;
delete sockSrv;
return NULL;
}
+ m_lastError = wxPROTO_NOERR;
sockSrv->Notify(false); // Don't send any events
return sockSrv;
}
wxSocketBase *wxFTP::GetPassivePort()
{
- if ( !DoSimpleCommand(_T("PASV")) )
+ if ( !DoSimpleCommand(wxT("PASV")) )
{
+ m_lastError = wxPROTO_PROTERR;
wxLogError(_("The FTP server doesn't support passive mode."));
return NULL;
}
- size_t addrStart = m_lastResult.find(_T('('));
+ size_t addrStart = m_lastResult.find(wxT('('));
size_t addrEnd = (addrStart == wxString::npos)
? wxString::npos
- : m_lastResult.find(_T(')'), addrStart);
+ : m_lastResult.find(wxT(')'), addrStart);
if ( addrEnd == wxString::npos )
{
wxSocketClient *client = new wxSocketClient();
if ( !client->Connect(addr) )
{
+ m_lastError = wxPROTO_CONNERR;
delete client;
return NULL;
}
client->Notify(false);
+ m_lastError = wxPROTO_NOERR;
return client;
}
-bool wxFTP::Abort()
+
+// ----------------------------------------------------------------------------
+// wxFTP download and upload
+// ----------------------------------------------------------------------------
+
+class wxInputFTPStream : public wxSocketInputStream
{
- if ( !m_streaming )
- return true;
+public:
+ wxInputFTPStream(wxFTP *ftp, wxSocketBase *sock)
+ : wxSocketInputStream(*sock)
+ {
+ m_ftp = ftp;
+ // socket timeout automatically set in GetPort function
+ }
- m_streaming = false;
- if ( !CheckCommand(wxT("ABOR"), '4') )
- return false;
+ virtual ~wxInputFTPStream()
+ {
+ delete m_i_socket; // keep at top
- return 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
+
+ // 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;
+ }
+ // 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;
+ }
+ // 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;
+
+ wxDECLARE_NO_COPY_CLASS(wxInputFTPStream);
+};
+
+class wxOutputFTPStream : public wxSocketOutputStream
+{
+public:
+ wxOutputFTPStream(wxFTP *ftp_clt, wxSocketBase *sock)
+ : wxSocketOutputStream(*sock), m_ftp(ftp_clt)
+ {
+ }
+
+ virtual ~wxOutputFTPStream(void)
+ {
+ if ( IsOk() )
+ {
+ // close data connection first, this will generate "transfer
+ // completed" reply
+ delete m_o_socket;
+
+ // read this reply
+ m_ftp->GetResult(); // save result so user can get to it
+
+ m_ftp->m_streaming = false;
+ }
+ else
+ {
+ // abort data connection first
+ m_ftp->Abort();
+
+ // and close it after
+ delete m_o_socket;
+ }
+ }
+
+ wxFTP *m_ftp;
+
+ wxDECLARE_NO_COPY_CLASS(wxOutputFTPStream);
+};
wxInputStream *wxFTP::GetInputStream(const wxString& path)
{
if ( ( m_currentTransfermode == NONE ) && !SetTransferMode(BINARY) )
+ {
+ m_lastError = wxPROTO_CONNERR;
return NULL;
+ }
wxSocketBase *sock = GetPort();
sock = AcceptIfActive(sock);
if ( !sock )
+ {
+ m_lastError = wxPROTO_CONNERR;
return NULL;
+ }
sock->SetFlags(wxSOCKET_WAITALL);
wxInputFTPStream *in_stream = new wxInputFTPStream(this, sock);
+ m_lastError = wxPROTO_NOERR;
return in_stream;
}
wxOutputStream *wxFTP::GetOutputStream(const wxString& path)
{
if ( ( m_currentTransfermode == NONE ) && !SetTransferMode(BINARY) )
+ {
+ m_lastError = wxPROTO_CONNERR;
return NULL;
+ }
wxSocketBase *sock = GetPort();
m_streaming = true;
+ m_lastError = wxPROTO_NOERR;
return new wxOutputFTPStream(this, sock);
}
bool details)
{
wxSocketBase *sock = GetPort();
- if (!sock)
+ if (!sock) {
+ m_lastError = wxPROTO_NETERR;
return false;
+ }
// NLST : List of Filenames (including Directory's !)
// LIST : depending on BS of FTP-Server
// - Unix : result like "ls" command
// - Windows : like "dir" command
// - others : ?
- wxString line(details ? _T("LIST") : _T("NLST"));
+ wxString line(details ? wxT("LIST") : wxT("NLST"));
if ( !wildcard.empty() )
{
- line << _T(' ') << wildcard;
+ line << wxT(' ') << wildcard;
}
if ( !CheckCommand(line, '1') )
{
m_lastError = wxPROTO_PROTERR;
- wxLogDebug(_T("FTP 'LIST' command returned unexpected result from server"));
+ wxLogDebug(wxT("FTP 'LIST' command returned unexpected result from server"));
delete sock;
return false;
}
sock = AcceptIfActive(sock);
- if ( !sock )
+ if ( !sock ) {
+ m_lastError = wxPROTO_CONNERR;
return false;
+ }
files.Empty();
while (ReadLine(sock, line) == wxPROTO_NOERR )
delete sock;
// the file list should be terminated by "226 Transfer complete""
+ m_lastError = wxPROTO_NOERR;
return CheckResult('2');
}
// will we need to hold this file?
TransferMode oldTransfermode = m_currentTransfermode;
SetTransferMode(BINARY);
- command << _T("SIZE ") << fileName;
+ command << wxT("SIZE ") << fileName;
bool ok = CheckCommand(command, '2');
// 213 is File Status (STD9)
// "SIZE" is not described anywhere..? It works on most servers
int statuscode;
- if ( wxSscanf(GetLastResult().c_str(), _T("%i %i"),
+ if ( wxSscanf(GetLastResult().c_str(), wxT("%i %i"),
&statuscode, &filesize) == 2 )
{
// We've gotten a good reply.
// check if the first character is '-'. This would
// indicate Unix-style (this also limits this function
// to searching for files, not directories)
- if ( fileList[i].Mid(0, 1) == _T("-") )
+ if ( fileList[i].Mid(0, 1) == wxT("-") )
{
if ( wxSscanf(fileList[i].c_str(),
- _T("%*s %*s %*s %*s %i %*s %*s %*s %*s"),
+ wxT("%*s %*s %*s %*s %i %*s %*s %*s %*s"),
&filesize) != 9 )
{
// Hmm... Invalid response
- wxLogTrace(FTP_TRACE_MASK,
- _T("Invalid LIST response"));
+ wxLogDebug(wxT("Invalid LIST response"));
}
}
else // Windows-style response (?)
{
if ( wxSscanf(fileList[i].c_str(),
- _T("%*s %*s %i %*s"),
+ wxT("%*s %*s %i %*s"),
&filesize) != 4 )
{
// something bad happened..?
- wxLogTrace(FTP_TRACE_MASK,
- _T("Invalid or unknown LIST response"));
+ wxLogDebug(wxT("Invalid or unknown LIST response"));
}
}
}
projects / wxWidgets.git / blobdiff