src/common/ftp.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        ftp.cpp
// Purpose:     FTP protocol
// Author:      Guilhem Lavaux
// Modified by:
// Created:     07/07/1997
// RCS-ID:      $Id$
// Copyright:   (c) 1997, 1998 Guilhem Lavaux
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
  #pragma implementation "ftp.h"
#endif

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
  #pragma hdrstop
#endif

#include "wx/setup.h"

#if wxUSE_SOCKETS && wxUSE_STREAMS

#ifndef __MWERKS__
#include <memory.h>
#endif
#if defined(__WXMAC__)
#include "/wx/mac/macsock.h"
#endif

#include <stdlib.h>
#include "wx/string.h"
#include "wx/utils.h"
#include "wx/sckaddr.h"
#include "wx/socket.h"
#include "wx/url.h"
#include "wx/sckstrm.h"
#include "wx/protocol/protocol.h"
#include "wx/protocol/ftp.h"
#include "wx/log.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

// the length of FTP status code (3 digits)
static const size_t LEN_CODE = 3;

#define FTP_BSIZE 1024

IMPLEMENT_DYNAMIC_CLASS(wxFTP, wxProtocol)
IMPLEMENT_PROTOCOL(wxFTP, wxT("ftp"), wxT("ftp"), TRUE)

////////////////////////////////////////////////////////////////
////// wxFTP constructor and destructor ////////////////////////
////////////////////////////////////////////////////////////////

wxFTP::wxFTP()
     : wxProtocol()
{
    m_lastError = wxPROTO_NOERR;
    m_streaming = FALSE;

    m_user = wxT("anonymous");
    m_passwd << wxGetUserId() << wxT('@') << wxGetFullHostName();

    SetNotify(0);
    SetFlags(wxSOCKET_NONE);
}

wxFTP::~wxFTP()
{
    if ( m_streaming )
    {
        (void)Abort();
    }

    Close();
}

////////////////////////////////////////////////////////////////
////// wxFTP connect and login methods /////////////////////////
////////////////////////////////////////////////////////////////
bool wxFTP::Connect(wxSockAddress& addr, bool WXUNUSED(wait))
{
  if (!wxProtocol::Connect(addr)) {
    m_lastError = wxPROTO_NETERR;
    return FALSE;
  }

  if (!m_user || !m_passwd) {
    m_lastError = wxPROTO_CONNERR;
    return FALSE;
  }

  wxString command;

  if (!GetResult('2')) {
    Close();
    return FALSE;
  }

  command.sprintf(wxT("USER %s"), (const wxChar *)m_user);
  if (!SendCommand(command, '3')) {
    Close();
    return FALSE;
  }

  command.sprintf(wxT("PASS %s"), (const wxChar *)m_passwd);
  if (!SendCommand(command, '2')) {
    Close();
    return FALSE;
  }

  return TRUE;
}

bool wxFTP::Connect(const wxString& host)
{
  wxIPV4address addr;
  wxString my_host = host;

  addr.Hostname(my_host);
  addr.Service(wxT("ftp"));

  return Connect(addr);
}

bool wxFTP::Close()
{
    if ( m_streaming )
    {
        m_lastError = wxPROTO_STREAMING;
        return FALSE;
    }

    if ( IsConnected() )
        SendCommand(wxT("QUIT"), '2');

    return wxSocketClient::Close();
}

// ============================================================================
// low level methods
// ============================================================================

// ----------------------------------------------------------------------------
// Send command to FTP server
// ----------------------------------------------------------------------------

bool wxFTP::SendCommand(const wxString& command, char exp_ret)
{
    wxString tmp_str;

    if (m_streaming)
    {
        m_lastError = wxPROTO_STREAMING;
        return FALSE;
    }

    tmp_str = command + wxT("\r\n");
    const wxWX2MBbuf tmp_buf = tmp_str.mb_str();
    if ( Write(wxMBSTRINGCAST tmp_buf, strlen(tmp_buf)).Error())
    {
        m_lastError = wxPROTO_NETERR;
        return FALSE;
    }

    wxLogTrace(_T("ftp"), _T("==> %s"), command.c_str());

    return GetResult(exp_ret);
}

// ----------------------------------------------------------------------------
// Recieve servers reply
// ----------------------------------------------------------------------------

bool wxFTP::GetResult(char exp)
{
    wxString code;

    // we handle multiline replies here according to RFC 959: it says that a
    // reply may either be on 1 line of the form "xyz ..." or on several lines
    // in whuch case it looks like
    //      xyz-...
    //      ...
    //      xyz ...
    // and the intermeidate lines may start with xyz or not
    bool badReply = FALSE;
    bool firstLine = TRUE;
    bool endOfReply = FALSE;
    while ( !endOfReply && !badReply )
    {
        m_lastError = ReadLine(m_lastResult);
        if ( m_lastError )
            return FALSE;

        // unless this is an intermediate line of a multiline reply, it must
        // contain the code in the beginning and '-' or ' ' following it
        if ( m_lastResult.Len() < LEN_CODE + 1 )
        {
            if ( firstLine )
            {
                badReply = TRUE;
            }
            else
            {
                wxLogTrace(_T("ftp"), _T("<== %s %s"),
                           code.c_str(), m_lastResult.c_str());
            }
        }
        else // line has at least 4 chars
        {
            // this is the char which tells us what we're dealing with
            wxChar chMarker = m_lastResult.GetChar(LEN_CODE);

            if ( firstLine )
            {
                code = wxString(m_lastResult, LEN_CODE);
                wxLogTrace(_T("ftp"), _T("<== %s %s"),
                           code.c_str(), m_lastResult.c_str() + LEN_CODE + 1);

                switch ( chMarker )
                {
                    case _T(' '):
                        endOfReply = TRUE;
                        break;

                    case _T('-'):
                        firstLine = FALSE;
                        break;

                    default:
                        // unexpected
                        badReply = TRUE;
                }
            }
            else // subsequent line of multiline reply
            {
                if ( wxStrncmp(m_lastResult, code, LEN_CODE) == 0 )
                {
                    if ( chMarker == _T(' ') )
                    {
                        endOfReply = TRUE;
                    }

                    wxLogTrace(_T("ftp"), _T("<== %s %s"),
                               code.c_str(), m_lastResult.c_str() + LEN_CODE + 1);
                }
                else
                {
                    // just part of reply
                    wxLogTrace(_T("ftp"), _T("<== %s %s"),
                               code.c_str(), m_lastResult.c_str());
                }
            }
        }
    }

    if ( badReply )
    {
        wxLogDebug(_T("Broken FTP server: '%s' is not a valid reply."),
                   m_lastResult.c_str());

        m_lastError = wxPROTO_PROTERR;

        return FALSE;
    }

    if ( code.GetChar(0) != exp )
    {
        m_lastError = wxPROTO_PROTERR;

        return FALSE;
    }

    return TRUE;
}

////////////////////////////////////////////////////////////////
////// wxFTP low-level methods /////////////////////////////////
////////////////////////////////////////////////////////////////
bool wxFTP::ChDir(const wxString& dir)
{
  wxString str = dir;

  str.Prepend(wxT("CWD "));
  return SendCommand(str, '2');
}

bool wxFTP::MkDir(const wxString& dir)
{
  wxString str = dir;
  str.Prepend(wxT("MKD "));
  return SendCommand(str, '2');
}

bool wxFTP::RmDir(const wxString& dir)
{
  wxString str = dir;

  str.Prepend(wxT("PWD "));
  return SendCommand(str, '2');
}

wxString wxFTP::Pwd()
{
    wxString path;

    if ( SendCommand(wxT("PWD"), '2') )
    {
        // the result is at least that long if SendCommand() succeeded
        const wxChar *p = m_lastResult.c_str() + LEN_CODE + 1;
        if ( *p != _T('"') )
        {
            wxLogDebug(_T("Missing starting quote in reply for PWD: %s"), p);
        }
        else
        {
            for ( p++; *p; p++ )
            {
                if ( *p == _T('"') )
                {
                    // check if the quote is doubled
                    p++;
                    if ( !*p || *p != _T('"') )
                    {
                        // no, this is the end
                        break;
                    }
                    //else: yes, it is: this is an embedded quote in the
                    //      filename, treat as normal char
                }

                path += *p;
            }

            if ( !*p )
            {
                wxLogDebug(_T("Missing ending quote in reply for PWD: %s"),
                           m_lastResult.c_str() + LEN_CODE + 1);
            }
        }
    }

    return path;
}

bool wxFTP::Rename(const wxString& src, const wxString& dst)
{
  wxString str;

  str = wxT("RNFR ") + src;
  if (!SendCommand(str, '3'))
    return FALSE;

  str = wxT("RNTO ") + dst;
  return SendCommand(str, '2');
}

bool wxFTP::RmFile(const wxString& path)
{
  wxString str;

  str = wxT("DELE ");
  str += path;
  return SendCommand(str, '2');
}

////////////////////////////////////////////////////////////////
////// wxFTP download*upload ///////////////////////////////////
////////////////////////////////////////////////////////////////

class wxInputFTPStream : public wxSocketInputStream {
public:
  wxFTP *m_ftp;
  size_t m_ftpsize;

  wxInputFTPStream(wxFTP *ftp_clt, wxSocketBase *sock)
    : wxSocketInputStream(*sock), m_ftp(ftp_clt) {}
  size_t GetSize() const { return m_ftpsize; }
  virtual ~wxInputFTPStream(void)
  {
     if (LastError() == wxStream_NOERROR)
       m_ftp->GetResult('2');
     else
       m_ftp->Abort();
     delete m_i_socket;
  }
};

class wxOutputFTPStream : public wxSocketOutputStream {
public:
  wxFTP *m_ftp;

  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('2');
      }
      else
      {
          // abort data connection first
          m_ftp->Abort();

          // and close it after
          delete m_o_socket;
      }
  }
};

wxSocketClient *wxFTP::GetPort()
{
  wxIPV4address addr;
  wxSocketClient *client;
  int a[6];
  wxString straddr;
  int addr_pos;
  wxUint16 port;
  wxUint32 hostaddr;

  if (!SendCommand(wxT("PASV"), '2'))
    return NULL;

  addr_pos = m_lastResult.Find(wxT('('));
  if (addr_pos == -1) {
    m_lastError = wxPROTO_PROTERR;
    return NULL;
  }
  straddr = m_lastResult(addr_pos+1, m_lastResult.Length());
  wxSscanf((const wxChar *)straddr,wxT("%d,%d,%d,%d,%d,%d"),&a[2],&a[3],&a[4],&a[5],&a[0],&a[1]);

  hostaddr = (wxUint16)a[5] << 24 | (wxUint16)a[4] << 16 |
             (wxUint16)a[3] << 8 | a[2];
  addr.Hostname(hostaddr);

  port = (wxUint16)a[0] << 8 | a[1];
  addr.Service(port);

  client = new wxSocketClient();
  if (!client->Connect(addr)) {
    delete client;
    return NULL;
  }
  client->Notify(FALSE);

  return client;
}

bool wxFTP::Abort()
{
    if ( !m_streaming )
        return TRUE;

    m_streaming = FALSE;
    if ( !SendCommand(wxT("ABOR"), '4') )
        return FALSE;

    return GetResult('2');
}

wxInputStream *wxFTP::GetInputStream(const wxString& path)
{
  wxString tmp_str;
  int pos_size;
  wxInputFTPStream *in_stream;

  if (!SendCommand(wxT("TYPE I"), '2'))
    return NULL;

  wxSocketClient *sock = GetPort();

  if (!sock) {
    m_lastError = wxPROTO_NETERR;
    return NULL;
  }

  tmp_str = wxT("RETR ") + wxURL::ConvertFromURI(path);
  if (!SendCommand(tmp_str, '1'))
    return NULL;

  in_stream = new wxInputFTPStream(this, sock);

  pos_size = m_lastResult.Index(wxT('('));
  if (pos_size != wxNOT_FOUND) {
    wxString str_size = m_lastResult(pos_size+1, m_lastResult.Index(wxT(')'))-1);

    in_stream->m_ftpsize = wxAtoi(WXSTRINGCAST str_size);
  }
  sock->SetFlags(wxSOCKET_WAITALL);

  return in_stream;
}

wxOutputStream *wxFTP::GetOutputStream(const wxString& path)
{
  wxString tmp_str;

  if (!SendCommand(wxT("TYPE I"), '2'))
    return NULL;

  wxSocketClient *sock = GetPort();

  tmp_str = wxT("STOR ") + path;
  if (!SendCommand(tmp_str, '1'))
    return FALSE;

  return new wxOutputFTPStream(this, sock);
}

bool wxFTP::GetList(wxArrayString& files, const wxString& wildcard)
{
    wxSocketBase *sock = GetPort();
    if ( !sock )
    {
        return FALSE;
    }

    wxString line = _T("NLST");
    if ( !!wildcard )
    {
        // notice that there is no space here
        line += wildcard;
    }

    if ( !SendCommand(line, '1') )
    {
        return FALSE;
    }

    files.Empty();

    while ( ReadLine(sock, line) == wxPROTO_NOERR )
    {
        files.Add(line);
    }

    delete sock;

    // the file list should be terminated by "226 Transfer complete""
    if ( !GetResult('2') )
        return FALSE;

    return TRUE;
}

wxList *wxFTP::GetList(const wxString& wildcard)
{
  wxList *file_list = new wxList;
  wxSocketBase *sock = GetPort();
  wxString tmp_str = wxT("NLST");

  if (!wildcard.IsNull())
    tmp_str += wildcard;

  if (!SendCommand(tmp_str, '1')) {
    delete sock;
    delete file_list;
    return NULL;
  }

  while (GetLine(sock, tmp_str) == wxPROTO_NOERR) {
    file_list->Append((wxObject *)(new wxString(tmp_str)));
  }

  if (!GetResult('2')) {
    delete sock;
    file_list->DeleteContents(TRUE);
    delete file_list;
    return NULL;
  }

  return file_list;
}
#endif
  // wxUSE_SOCKETS
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: ftp.cpp
	3	// Purpose: FTP protocol
	4	// Author: Guilhem Lavaux
	5	// Modified by:
	6	// Created: 07/07/1997
	7	// RCS-ID: $Id$
	8	// Copyright: (c) 1997, 1998 Guilhem Lavaux
	9	// Licence: wxWindows license
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#ifdef __GNUG__
	13	#pragma implementation "ftp.h"
	14	#endif
	15
	16	// For compilers that support precompilation, includes "wx.h".
	17	#include "wx/wxprec.h"
	18
	19	#ifdef __BORLANDC__
	20	#pragma hdrstop
	21	#endif
	22
	23	#include "wx/setup.h"
	24
	25	#if wxUSE_SOCKETS && wxUSE_STREAMS
	26
	27	#ifndef __MWERKS__
	28	#include <memory.h>
	29	#endif
	30	#if defined(__WXMAC__)
	31	#include "/wx/mac/macsock.h"
	32	#endif
	33
	34	#include <stdlib.h>
	35	#include "wx/string.h"
	36	#include "wx/utils.h"
	37	#include "wx/sckaddr.h"
	38	#include "wx/socket.h"
	39	#include "wx/url.h"
	40	#include "wx/sckstrm.h"
	41	#include "wx/protocol/protocol.h"
	42	#include "wx/protocol/ftp.h"
	43	#include "wx/log.h"
	44
	45	#ifdef __BORLANDC__
	46	#pragma hdrstop
	47	#endif
	48
	49	// the length of FTP status code (3 digits)
	50	static const size_t LEN_CODE = 3;
	51
	52	#define FTP_BSIZE 1024
	53
	54	IMPLEMENT_DYNAMIC_CLASS(wxFTP, wxProtocol)
	55	IMPLEMENT_PROTOCOL(wxFTP, wxT("ftp"), wxT("ftp"), TRUE)
	56
	57	////////////////////////////////////////////////////////////////
	58	////// wxFTP constructor and destructor ////////////////////////
	59	////////////////////////////////////////////////////////////////
	60
	61	wxFTP::wxFTP()
	62	: wxProtocol()
	63	{
	64	m_lastError = wxPROTO_NOERR;
	65	m_streaming = FALSE;
	66
	67	m_user = wxT("anonymous");
	68	m_passwd << wxGetUserId() << wxT('@') << wxGetFullHostName();
	69
	70	SetNotify(0);
	71	SetFlags(wxSOCKET_NONE);
	72	}
	73
	74	wxFTP::~wxFTP()
	75	{
	76	if ( m_streaming )
	77	{
	78	(void)Abort();
	79	}
	80
	81	Close();
	82	}
	83
	84	////////////////////////////////////////////////////////////////
	85	////// wxFTP connect and login methods /////////////////////////
	86	////////////////////////////////////////////////////////////////
	87	bool wxFTP::Connect(wxSockAddress& addr, bool WXUNUSED(wait))
	88	{
	89	if (!wxProtocol::Connect(addr)) {
	90	m_lastError = wxPROTO_NETERR;
	91	return FALSE;
	92	}
	93
	94	if (!m_user \|\| !m_passwd) {
	95	m_lastError = wxPROTO_CONNERR;
	96	return FALSE;
	97	}
	98
	99	wxString command;
	100
	101	if (!GetResult('2')) {
	102	Close();
	103	return FALSE;
	104	}
	105
	106	command.sprintf(wxT("USER %s"), (const wxChar *)m_user);
	107	if (!SendCommand(command, '3')) {
	108	Close();
	109	return FALSE;
	110	}
	111
	112	command.sprintf(wxT("PASS %s"), (const wxChar *)m_passwd);
	113	if (!SendCommand(command, '2')) {
	114	Close();
	115	return FALSE;
	116	}
	117
	118	return TRUE;
	119	}
	120
	121	bool wxFTP::Connect(const wxString& host)
	122	{
	123	wxIPV4address addr;
	124	wxString my_host = host;
	125
	126	addr.Hostname(my_host);
	127	addr.Service(wxT("ftp"));
	128
	129	return Connect(addr);
	130	}
	131
	132	bool wxFTP::Close()
	133	{
	134	if ( m_streaming )
	135	{
	136	m_lastError = wxPROTO_STREAMING;
	137	return FALSE;
	138	}
	139
	140	if ( IsConnected() )
	141	SendCommand(wxT("QUIT"), '2');
	142
	143	return wxSocketClient::Close();
	144	}
	145
	146	// ============================================================================
	147	// low level methods
	148	// ============================================================================
	149
	150	// ----------------------------------------------------------------------------
	151	// Send command to FTP server
	152	// ----------------------------------------------------------------------------
	153
	154	bool wxFTP::SendCommand(const wxString& command, char exp_ret)
	155	{
	156	wxString tmp_str;
	157
	158	if (m_streaming)
	159	{
	160	m_lastError = wxPROTO_STREAMING;
	161	return FALSE;
	162	}
	163
	164	tmp_str = command + wxT("\r\n");
	165	const wxWX2MBbuf tmp_buf = tmp_str.mb_str();
	166	if ( Write(wxMBSTRINGCAST tmp_buf, strlen(tmp_buf)).Error())
	167	{
	168	m_lastError = wxPROTO_NETERR;
	169	return FALSE;
	170	}
	171
	172	wxLogTrace(_T("ftp"), _T("==> %s"), command.c_str());
	173
	174	return GetResult(exp_ret);
	175	}
	176
	177	// ----------------------------------------------------------------------------
	178	// Recieve servers reply
	179	// ----------------------------------------------------------------------------
	180
	181	bool wxFTP::GetResult(char exp)
	182	{
	183	wxString code;
	184
	185	// we handle multiline replies here according to RFC 959: it says that a
	186	// reply may either be on 1 line of the form "xyz ..." or on several lines
	187	// in whuch case it looks like
	188	// xyz-...
	189	// ...
	190	// xyz ...
	191	// and the intermeidate lines may start with xyz or not
	192	bool badReply = FALSE;
	193	bool firstLine = TRUE;
	194	bool endOfReply = FALSE;
	195	while ( !endOfReply && !badReply )
	196	{
	197	m_lastError = ReadLine(m_lastResult);
	198	if ( m_lastError )
	199	return FALSE;
	200
	201	// unless this is an intermediate line of a multiline reply, it must
	202	// contain the code in the beginning and '-' or ' ' following it
	203	if ( m_lastResult.Len() < LEN_CODE + 1 )
	204	{
	205	if ( firstLine )
	206	{
	207	badReply = TRUE;
	208	}
	209	else
	210	{
	211	wxLogTrace(_T("ftp"), _T("<== %s %s"),
	212	code.c_str(), m_lastResult.c_str());
	213	}
	214	}
	215	else // line has at least 4 chars
	216	{
	217	// this is the char which tells us what we're dealing with
	218	wxChar chMarker = m_lastResult.GetChar(LEN_CODE);
	219
	220	if ( firstLine )
	221	{
	222	code = wxString(m_lastResult, LEN_CODE);
	223	wxLogTrace(_T("ftp"), _T("<== %s %s"),
	224	code.c_str(), m_lastResult.c_str() + LEN_CODE + 1);
	225
	226	switch ( chMarker )
	227	{
	228	case _T(' '):
	229	endOfReply = TRUE;
	230	break;
	231
	232	case _T('-'):
	233	firstLine = FALSE;
	234	break;
	235
	236	default:
	237	// unexpected
	238	badReply = TRUE;
	239	}
	240	}
	241	else // subsequent line of multiline reply
	242	{
	243	if ( wxStrncmp(m_lastResult, code, LEN_CODE) == 0 )
	244	{
	245	if ( chMarker == _T(' ') )
	246	{
	247	endOfReply = TRUE;
	248	}
	249
	250	wxLogTrace(_T("ftp"), _T("<== %s %s"),
	251	code.c_str(), m_lastResult.c_str() + LEN_CODE + 1);
	252	}
	253	else
	254	{
	255	// just part of reply
	256	wxLogTrace(_T("ftp"), _T("<== %s %s"),
	257	code.c_str(), m_lastResult.c_str());
	258	}
	259	}
	260	}
	261	}
	262
	263	if ( badReply )
	264	{
	265	wxLogDebug(_T("Broken FTP server: '%s' is not a valid reply."),
	266	m_lastResult.c_str());
	267
	268	m_lastError = wxPROTO_PROTERR;
	269
	270	return FALSE;
	271	}
	272
	273	if ( code.GetChar(0) != exp )
	274	{
	275	m_lastError = wxPROTO_PROTERR;
	276
	277	return FALSE;
	278	}
	279
	280	return TRUE;
	281	}
	282
	283	////////////////////////////////////////////////////////////////
	284	////// wxFTP low-level methods /////////////////////////////////
	285	////////////////////////////////////////////////////////////////
	286	bool wxFTP::ChDir(const wxString& dir)
	287	{
	288	wxString str = dir;
	289
	290	str.Prepend(wxT("CWD "));
	291	return SendCommand(str, '2');
	292	}
	293
	294	bool wxFTP::MkDir(const wxString& dir)
	295	{
	296	wxString str = dir;
	297	str.Prepend(wxT("MKD "));
	298	return SendCommand(str, '2');
	299	}
	300
	301	bool wxFTP::RmDir(const wxString& dir)
	302	{
	303	wxString str = dir;
	304
	305	str.Prepend(wxT("PWD "));
	306	return SendCommand(str, '2');
	307	}
	308
	309	wxString wxFTP::Pwd()
	310	{
	311	wxString path;
	312
	313	if ( SendCommand(wxT("PWD"), '2') )
	314	{
	315	// the result is at least that long if SendCommand() succeeded
	316	const wxChar *p = m_lastResult.c_str() + LEN_CODE + 1;
	317	if ( *p != _T('"') )
	318	{
	319	wxLogDebug(_T("Missing starting quote in reply for PWD: %s"), p);
	320	}
	321	else
	322	{
	323	for ( p++; *p; p++ )
	324	{
	325	if ( *p == _T('"') )
	326	{
	327	// check if the quote is doubled
	328	p++;
	329	if ( !p \|\| p != _T('"') )
	330	{
	331	// no, this is the end
	332	break;
	333	}
	334	//else: yes, it is: this is an embedded quote in the
	335	// filename, treat as normal char
	336	}
	337
	338	path += *p;
	339	}
	340
	341	if ( !*p )
	342	{
	343	wxLogDebug(_T("Missing ending quote in reply for PWD: %s"),
	344	m_lastResult.c_str() + LEN_CODE + 1);
	345	}
	346	}
	347	}
	348
	349	return path;
	350	}
	351
	352	bool wxFTP::Rename(const wxString& src, const wxString& dst)
	353	{
	354	wxString str;
	355
	356	str = wxT("RNFR ") + src;
	357	if (!SendCommand(str, '3'))
	358	return FALSE;
	359
	360	str = wxT("RNTO ") + dst;
	361	return SendCommand(str, '2');
	362	}
	363
	364	bool wxFTP::RmFile(const wxString& path)
	365	{
	366	wxString str;
	367
	368	str = wxT("DELE ");
	369	str += path;
	370	return SendCommand(str, '2');
	371	}
	372
	373	////////////////////////////////////////////////////////////////
	374	////// wxFTP download*upload ///////////////////////////////////
	375	////////////////////////////////////////////////////////////////
	376
	377	class wxInputFTPStream : public wxSocketInputStream {
	378	public:
	379	wxFTP *m_ftp;
	380	size_t m_ftpsize;
	381
	382	wxInputFTPStream(wxFTP ftp_clt, wxSocketBase sock)
	383	: wxSocketInputStream(*sock), m_ftp(ftp_clt) {}
	384	size_t GetSize() const { return m_ftpsize; }
	385	virtual ~wxInputFTPStream(void)
	386	{
	387	if (LastError() == wxStream_NOERROR)
	388	m_ftp->GetResult('2');
	389	else
	390	m_ftp->Abort();
	391	delete m_i_socket;
	392	}
	393	};
	394
	395	class wxOutputFTPStream : public wxSocketOutputStream {
	396	public:
	397	wxFTP *m_ftp;
	398
	399	wxOutputFTPStream(wxFTP ftp_clt, wxSocketBase sock)
	400	: wxSocketOutputStream(*sock), m_ftp(ftp_clt) {}
	401	virtual ~wxOutputFTPStream(void)
	402	{
	403	if ( IsOk() )
	404	{
	405	// close data connection first, this will generate "transfer
	406	// completed" reply
	407	delete m_o_socket;
	408
	409	// read this reply
	410	m_ftp->GetResult('2');
	411	}
	412	else
	413	{
	414	// abort data connection first
	415	m_ftp->Abort();
	416
	417	// and close it after
	418	delete m_o_socket;
	419	}
	420	}
	421	};
	422
	423	wxSocketClient *wxFTP::GetPort()
	424	{
	425	wxIPV4address addr;
	426	wxSocketClient *client;
	427	int a[6];
	428	wxString straddr;
	429	int addr_pos;
	430	wxUint16 port;
	431	wxUint32 hostaddr;
	432
	433	if (!SendCommand(wxT("PASV"), '2'))
	434	return NULL;
	435
	436	addr_pos = m_lastResult.Find(wxT('('));
	437	if (addr_pos == -1) {
	438	m_lastError = wxPROTO_PROTERR;
	439	return NULL;
	440	}
	441	straddr = m_lastResult(addr_pos+1, m_lastResult.Length());
	442	wxSscanf((const wxChar *)straddr,wxT("%d,%d,%d,%d,%d,%d"),&a[2],&a[3],&a[4],&a[5],&a[0],&a[1]);
	443
	444	hostaddr = (wxUint16)a[5] << 24 \| (wxUint16)a[4] << 16 \|
	445	(wxUint16)a[3] << 8 \| a[2];
	446	addr.Hostname(hostaddr);
	447
	448	port = (wxUint16)a[0] << 8 \| a[1];
	449	addr.Service(port);
	450
	451	client = new wxSocketClient();
	452	if (!client->Connect(addr)) {
	453	delete client;
	454	return NULL;
	455	}
	456	client->Notify(FALSE);
	457
	458	return client;
	459	}
	460
	461	bool wxFTP::Abort()
	462	{
	463	if ( !m_streaming )
	464	return TRUE;
	465
	466	m_streaming = FALSE;
	467	if ( !SendCommand(wxT("ABOR"), '4') )
	468	return FALSE;
	469
	470	return GetResult('2');
	471	}
	472
	473	wxInputStream *wxFTP::GetInputStream(const wxString& path)
	474	{
	475	wxString tmp_str;
	476	int pos_size;
	477	wxInputFTPStream *in_stream;
	478
	479	if (!SendCommand(wxT("TYPE I"), '2'))
	480	return NULL;
	481
	482	wxSocketClient *sock = GetPort();
	483
	484	if (!sock) {
	485	m_lastError = wxPROTO_NETERR;
	486	return NULL;
	487	}
	488
	489	tmp_str = wxT("RETR ") + wxURL::ConvertFromURI(path);
	490	if (!SendCommand(tmp_str, '1'))
	491	return NULL;
	492
	493	in_stream = new wxInputFTPStream(this, sock);
	494
	495	pos_size = m_lastResult.Index(wxT('('));
	496	if (pos_size != wxNOT_FOUND) {
	497	wxString str_size = m_lastResult(pos_size+1, m_lastResult.Index(wxT(')'))-1);
	498
	499	in_stream->m_ftpsize = wxAtoi(WXSTRINGCAST str_size);
	500	}
	501	sock->SetFlags(wxSOCKET_WAITALL);
	502
	503	return in_stream;
	504	}
	505
	506	wxOutputStream *wxFTP::GetOutputStream(const wxString& path)
	507	{
	508	wxString tmp_str;
	509
	510	if (!SendCommand(wxT("TYPE I"), '2'))
	511	return NULL;
	512
	513	wxSocketClient *sock = GetPort();
	514
	515	tmp_str = wxT("STOR ") + path;
	516	if (!SendCommand(tmp_str, '1'))
	517	return FALSE;
	518
	519	return new wxOutputFTPStream(this, sock);
	520	}
	521
	522	bool wxFTP::GetList(wxArrayString& files, const wxString& wildcard)
	523	{
	524	wxSocketBase *sock = GetPort();
	525	if ( !sock )
	526	{
	527	return FALSE;
	528	}
	529
	530	wxString line = _T("NLST");
	531	if ( !!wildcard )
	532	{
	533	// notice that there is no space here
	534	line += wildcard;
	535	}
	536
	537	if ( !SendCommand(line, '1') )
	538	{
	539	return FALSE;
	540	}
	541
	542	files.Empty();
	543
	544	while ( ReadLine(sock, line) == wxPROTO_NOERR )
	545	{
	546	files.Add(line);
	547	}
	548
	549	delete sock;
	550
	551	// the file list should be terminated by "226 Transfer complete""
	552	if ( !GetResult('2') )
	553	return FALSE;
	554
	555	return TRUE;
	556	}
	557
	558	wxList *wxFTP::GetList(const wxString& wildcard)
	559	{
	560	wxList *file_list = new wxList;
	561	wxSocketBase *sock = GetPort();
	562	wxString tmp_str = wxT("NLST");
	563
	564	if (!wildcard.IsNull())
	565	tmp_str += wildcard;
	566
	567	if (!SendCommand(tmp_str, '1')) {
	568	delete sock;
	569	delete file_list;
	570	return NULL;
	571	}
	572
	573	while (GetLine(sock, tmp_str) == wxPROTO_NOERR) {
	574	file_list->Append((wxObject *)(new wxString(tmp_str)));
	575	}
	576
	577	if (!GetResult('2')) {
	578	delete sock;
	579	file_list->DeleteContents(TRUE);
	580	delete file_list;
	581	return NULL;
	582	}
	583
	584	return file_list;
	585	}
	586	#endif
	587	// wxUSE_SOCKETS