<testcase>
# Server-side
<reply>
</reply>

# Client-side
<client>
<server>
ftp
</server>
 <name>
FTP getting bad host in 227-response to PASV
 </name>
 <command>
ftp://%HOSTIP:%FTPPORT/237 --disable-epsv
</command>
<file name="log/ftpserver.cmd">
REPLY PASV 227 Entering Passiv Mode (1216,256,2,127,127,127)
</file>
</client>

# Verify data after the test has been "shot"
# The bogus address used here is chosen specifically so that when processed on
# certain hosts with buggy resolver code, the resulting address (192.0.2.127)
# is from an address block that is guaranteed never to be assigned (RFC3330).
<verify>
# curl: (15) Can't resolve new host 1216.256.2.127:32639
# 15 => CURLE_FTP_CANT_GET_HOST
# some systems just don't fail on the illegal host name/address but instead
# moves on and attempt to connect to... yes, to what?
# 7= CURLE_COULDNT_CONNECT
<errorcode>
15, 7
</errorcode>
<protocol>
USER anonymous
PASS curl_by_daniel@haxx.se
PWD
PASV
</protocol>
</verify>
</testcase>
