<testcase>
# Warning: if this test fails to start the SSH server, check that none of
# the user's shell profiles sends output to stdout of a non-interactive shell.
<info>
<keywords>
FTP
PASV
RETR
multi
SOCKS4
</keywords>
</info>
# Server-side
<reply>
<data>
data
    to
      see
that FTP
works
  so does it?
</data>

</reply>

# Client-side
<client>
<server>
ftp
socks4
</server>
<tool>
lib%TESTNUMBER
</tool>
 <name>
FTP RETR a file over a SOCKS proxy using the multi interface
 </name>
<command>
ftp://%HOSTIP:%FTPPORT/path/%TESTNUMBER %HOSTIP:%SOCKSPORT
</command>
<features>
proxy
</features>
</client>

# Verify data after the test has been "shot"
<verify>
<protocol>
USER anonymous
PASS ftp@example.com
PWD
CWD path
EPSV
TYPE I
SIZE %TESTNUMBER
RETR %TESTNUMBER
QUIT
</protocol>
<stdout>
data
    to
      see
that FTP
works
  so does it?
</stdout>
</verify>
</testcase>
