    001/*
    002 * Licensed to the Apache Software Foundation (ASF) under one or more
    003 * contributor license agreements.  See the NOTICE file distributed with
    004 * this work for additional information regarding copyright ownership.
    005 * The ASF licenses this file to You under the Apache License, Version 2.0
    006 * (the "License"); you may not use this file except in compliance with
    007 * the License.  You may obtain a copy of the License at
    008 *
    009 *      http://www.apache.org/licenses/LICENSE-2.0
    010 *
    011 * Unless required by applicable law or agreed to in writing, software
    012 * distributed under the License is distributed on an "AS IS" BASIS,
    013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014 * See the License for the specific language governing permissions and
    015 * limitations under the License.
    016 */
    017
    018package org.apache.commons.net.ftp;
    019import java.io.BufferedReader;
    020import java.io.BufferedWriter;
    021import java.io.IOException;
    022import java.io.InputStreamReader;
    023import java.io.OutputStreamWriter;
    024import java.io.Reader;
    025import java.net.Inet4Address;
    026import java.net.Inet6Address;
    027import java.net.InetAddress;
    028import java.net.SocketException;
    029import java.net.SocketTimeoutException;
    030import java.util.ArrayList;
    031
    032import org.apache.commons.net.MalformedServerReplyException;
    033import org.apache.commons.net.ProtocolCommandSupport;
    034import org.apache.commons.net.SocketClient;
    035import org.apache.commons.net.io.CRLFLineReader;
    036
    037/***
    038 * FTP provides the basic the functionality necessary to implement your
    039 * own FTP client.  It extends org.apache.commons.net.SocketClient since
    040 * extending TelnetClient was causing unwanted behavior (like connections
    041 * that did not time out properly).
    042 * <p>
    043 * To derive the full benefits of the FTP class requires some knowledge
    044 * of the FTP protocol defined in RFC 959.  However, there is no reason
    045 * why you should have to use the FTP class.  The
    046 * {@link org.apache.commons.net.ftp.FTPClient} class,
    047 * derived from FTP,
    048 * implements all the functionality required of an FTP client.  The
    049 * FTP class is made public to provide access to various FTP constants
    050 * and to make it easier for adventurous programmers (or those with
    051 * special needs) to interact with the FTP protocol and implement their
    052 * own clients.  A set of methods with names corresponding to the FTP
    053 * command names are provided to facilitate this interaction.
    054 * <p>
    055 * You should keep in mind that the FTP server may choose to prematurely
    056 * close a connection if the client has been idle for longer than a
    057 * given time period (usually 900 seconds).  The FTP class will detect a
    058 * premature FTP server connection closing when it receives a
    059 * {@link org.apache.commons.net.ftp.FTPReply#SERVICE_NOT_AVAILABLE FTPReply.SERVICE_NOT_AVAILABLE }
    060 *  response to a command.
    061 * When that occurs, the FTP class method encountering that reply will throw
    062 * an {@link org.apache.commons.net.ftp.FTPConnectionClosedException}
    063 * .  <code>FTPConectionClosedException</code>
    064 * is a subclass of <code> IOException </code> and therefore need not be
    065 * caught separately, but if you are going to catch it separately, its
    066 * catch block must appear before the more general <code> IOException </code>
    067 * catch block.  When you encounter an
    068 * {@link org.apache.commons.net.ftp.FTPConnectionClosedException}
    069 * , you must disconnect the connection with
    070 * {@link #disconnect  disconnect() } to properly clean up the
    071 * system resources used by FTP.  Before disconnecting, you may check the
    072 * last reply code and text with
    073 * {@link #getReplyCode  getReplyCode },
    074 * {@link #getReplyString  getReplyString },
    075 * and {@link #getReplyStrings  getReplyStrings}.
    076 * You may avoid server disconnections while the client is idle by
    077 * periodicaly sending NOOP commands to the server.
    078 * <p>
    079 * Rather than list it separately for each method, we mention here that
    080 * every method communicating with the server and throwing an IOException
    081 * can also throw a
    082 * {@link org.apache.commons.net.MalformedServerReplyException}
    083 * , which is a subclass
    084 * of IOException.  A MalformedServerReplyException will be thrown when
    085 * the reply received from the server deviates enough from the protocol
    086 * specification that it cannot be interpreted in a useful manner despite
    087 * attempts to be as lenient as possible.
    088 *
    089 * @see FTPClient
    090 * @see FTPConnectionClosedException
    091 * @see org.apache.commons.net.MalformedServerReplyException
    092 ***/
    093
    094public class FTP extends SocketClient
    095{
    096    /*** The default FTP data port (20). ***/
    097    public static final int DEFAULT_DATA_PORT = 20;
    098    /*** The default FTP control port (21). ***/
    099    public static final int DEFAULT_PORT = 21;
    100
    101    /***
    102     * A constant used to indicate the file(s) being transferred should
    103     * be treated as ASCII.  This is the default file type.  All constants
    104     * ending in <code>FILE_TYPE</code> are used to indicate file types.
    105     ***/
    106    public static final int ASCII_FILE_TYPE = 0;
    107
    108    /***
    109     * A constant used to indicate the file(s) being transferred should
    110     * be treated as EBCDIC.  Note however that there are several different
    111     * EBCDIC formats.  All constants ending in <code>FILE_TYPE</code>
    112     * are used to indicate file types.
    113     ***/
    114    public static final int EBCDIC_FILE_TYPE = 1;
    115
    116
    117    /***
    118     * A constant used to indicate the file(s) being transferred should
    119     * be treated as a binary image, i.e., no translations should be
    120     * performed.  All constants ending in <code>FILE_TYPE</code> are used to
    121     * indicate file types.
    122     ***/
    123    public static final int BINARY_FILE_TYPE = 2;
    124
    125    /***
    126     * A constant used to indicate the file(s) being transferred should
    127     * be treated as a local type.  All constants ending in
    128     * <code>FILE_TYPE</code> are used to indicate file types.
    129     ***/
    130    public static final int LOCAL_FILE_TYPE = 3;
    131
    132    /***
    133     * A constant used for text files to indicate a non-print text format.
    134     * This is the default format.
    135     * All constants ending in <code>TEXT_FORMAT</code> are used to indicate
    136     * text formatting for text transfers (both ASCII and EBCDIC).
    137     ***/
    138    public static final int NON_PRINT_TEXT_FORMAT = 4;
    139
    140    /***
    141     * A constant used to indicate a text file contains format vertical format
    142     * control characters.
    143     * All constants ending in <code>TEXT_FORMAT</code> are used to indicate
    144     * text formatting for text transfers (both ASCII and EBCDIC).
    145     ***/
    146    public static final int TELNET_TEXT_FORMAT = 5;
    147
    148    /***
    149     * A constant used to indicate a text file contains ASA vertical format
    150     * control characters.
    151     * All constants ending in <code>TEXT_FORMAT</code> are used to indicate
    152     * text formatting for text transfers (both ASCII and EBCDIC).
    153     ***/
    154    public static final int CARRIAGE_CONTROL_TEXT_FORMAT = 6;
    155
    156    /***
    157     * A constant used to indicate a file is to be treated as a continuous
    158     * sequence of bytes.  This is the default structure.  All constants ending
    159     * in <code>_STRUCTURE</code> are used to indicate file structure for
    160     * file transfers.
    161     ***/
    162    public static final int FILE_STRUCTURE = 7;
    163
    164    /***
    165     * A constant used to indicate a file is to be treated as a sequence
    166     * of records.  All constants ending in <code>_STRUCTURE</code>
    167     * are used to indicate file structure for file transfers.
    168     ***/
    169    public static final int RECORD_STRUCTURE = 8;
    170
    171    /***
    172     * A constant used to indicate a file is to be treated as a set of
    173     * independent indexed pages.  All constants ending in
    174     * <code>_STRUCTURE</code> are used to indicate file structure for file
    175     * transfers.
    176     ***/
    177    public static final int PAGE_STRUCTURE = 9;
    178
    179    /***
    180     * A constant used to indicate a file is to be transferred as a stream
    181     * of bytes.  This is the default transfer mode.  All constants ending
    182     * in <code>TRANSFER_MODE</code> are used to indicate file transfer
    183     * modes.
    184     ***/
    185    public static final int STREAM_TRANSFER_MODE = 10;
    186
    187    /***
    188     * A constant used to indicate a file is to be transferred as a series
    189     * of blocks.  All constants ending in <code>TRANSFER_MODE</code> are used
    190     * to indicate file transfer modes.
    191     ***/
    192    public static final int BLOCK_TRANSFER_MODE = 11;
    193
    194    /***
    195     * A constant used to indicate a file is to be transferred as FTP
    196     * compressed data.  All constants ending in <code>TRANSFER_MODE</code>
    197     * are used to indicate file transfer modes.
    198     ***/
    199    public static final int COMPRESSED_TRANSFER_MODE = 12;
    200
    201    // We have to ensure that the protocol communication is in ASCII
    202    // but we use ISO-8859-1 just in case 8-bit characters cross
    203    // the wire.
    204    /**
    205     * The default character encoding used for communicating over an
    206     * FTP control connection.  The default encoding is an
    207     * ASCII-compatible encoding.  Some FTP servers expect other
    208     * encodings.  You can change the encoding used by an FTP instance
    209     * with {@link #setControlEncoding setControlEncoding}.
    210     */
    211    public static final String DEFAULT_CONTROL_ENCODING = "ISO-8859-1";
    212
    213    /** Length of the FTP reply code (3 alphanumerics) */
    214    public static final int REPLY_CODE_LEN = 3;
    215
    216    private static final String modes = "AEILNTCFRPSBC";
    217
    218    protected int _replyCode;
    219    protected ArrayList<String> _replyLines;
    220    protected boolean _newReplyString;
    221    protected String _replyString;
    222    protected String _controlEncoding;
    223
    224    /**
    225     * A ProtocolCommandSupport object used to manage the registering of
    226     * ProtocolCommandListeners and te firing of ProtocolCommandEvents.
    227     */
    228    protected ProtocolCommandSupport _commandSupport_;
    229
    230    /**
    231     * This is used to signal whether a block of multiline responses beginning
    232     * with xxx must be terminated by the same numeric code xxx
    233     * See section 4.2 of RFC 959 for details.
    234     */
    235    protected boolean strictMultilineParsing = false;
    236
    237    /**
    238     * If this is true, then non-multiline replies must have the format:
    239     * 3 digit code <space> <text>
    240     * If false, then the 3 digit code does not have to be followed by space
    241     * See section 4.2 of RFC 959 for details.
    242     */
    243    private boolean strictReplyParsing = true;
    244
    245    /**
    246     * Wraps SocketClient._input_ to facilitate the reading of text
    247     * from the FTP control connection.  Do not access the control
    248     * connection via SocketClient._input_.  This member starts
    249     * with a null value, is initialized in {@link #_connectAction_},
    250     * and set to null in {@link #disconnect}.
    251     */
    252    protected BufferedReader _controlInput_;
    253
    254    /**
    255     * Wraps SocketClient._output_ to facilitate the writing of text
    256     * to the FTP control connection.  Do not access the control
    257     * connection via SocketClient._output_.  This member starts
    258     * with a null value, is initialized in {@link #_connectAction_},
    259     * and set to null in {@link #disconnect}.
    260     */
    261    protected BufferedWriter _controlOutput_;
    262
    263    /***
    264     * The default FTP constructor.  Sets the default port to
    265     * <code>DEFAULT_PORT</code> and initializes internal data structures
    266     * for saving FTP reply information.
    267     ***/
    268    public FTP()
    269    {
    270        super();
    271        setDefaultPort(DEFAULT_PORT);
    272        _replyLines = new ArrayList<>();
    273        _newReplyString = false;
    274        _replyString = null;
    275        _controlEncoding = DEFAULT_CONTROL_ENCODING;
    276        _commandSupport_ = new ProtocolCommandSupport(this);
    277    }
    278
    279    // The RFC-compliant multiline termination check
    280    private boolean __strictCheck(final String line, final String code) {
    281        return !(line.startsWith(code) && line.charAt(REPLY_CODE_LEN) == ' ');
    282    }
    283
    284    // The strict check is too strong a condition because of non-conforming ftp
    285    // servers like ftp.funet.fi which sent 226 as the last line of a
    286    // 426 multi-line reply in response to ls /.  We relax the condition to
    287    // test that the line starts with a digit rather than starting with
    288    // the code.
    289    private boolean __lenientCheck(final String line) {
    290        return !(line.length() > REPLY_CODE_LEN&& line.charAt(REPLY_CODE_LEN) != '-' &&
    291                Character.isDigit(line.charAt(0)));
    292    }
    293
    294    /**
    295     * Get the reply, and pass it to command listeners
    296     */
    297    private void __getReply()  throws IOException
    298    {
    299        __getReply(true);
    300    }
    301
    302    /**
    303     * Get the reply, but don't pass it to command listeners.
    304     * Used for keep-alive processing only.
    305     * @since 3.0
    306     * @throws IOException on error
    307     */
    308    protected void __getReplyNoReport()  throws IOException
    309    {
    310        __getReply(false);
    311    }
    312
    313    private void __getReply(final boolean reportReply) throws IOException
    314    {
    315        int length;
    316
    317        _newReplyString = true;
    318        _replyLines.clear();
    319
    320        String line = _controlInput_.readLine();
    321
    322        if (line == null) {
    323            throw new FTPConnectionClosedException(
    324                    "Connection closed without indication.");
    325        }
    326
    327        // In case we run into an anomaly we don't want fatal index exceptions
    328        // to be thrown.
    329        length = line.length();
    330        if (length < REPLY_CODE_LEN) {
    331            throw new MalformedServerReplyException(
    332                "Truncated server reply: " + line);
    333        }
    334
    335        String code = null;
    336        try
    337        {
    338            code = line.substring(0, REPLY_CODE_LEN);
    339            _replyCode = Integer.parseInt(code);
    340        }
    341        catch (final NumberFormatException e)
    342        {
    343            throw new MalformedServerReplyException(
    344                "Could not parse response code.\nServer Reply: " + line);
    345        }
    346
    347        _replyLines.add(line);
    348
    349        // Check the server reply type
    350        if (length > REPLY_CODE_LEN) {
    351            final char sep = line.charAt(REPLY_CODE_LEN);
    352            // Get extra lines if message continues.
    353            if (sep == '-') {
    354                do
    355                {
    356                    line = _controlInput_.readLine();
    357
    358                    if (line == null) {
    359                        throw new FTPConnectionClosedException(
    360                            "Connection closed without indication.");
    361                    }
    362
    363                    _replyLines.add(line);
    364
    365                    // The length() check handles problems that could arise from readLine()
    366                    // returning too soon after encountering a naked CR or some other
    367                    // anomaly.
    368                }
    369                while ( isStrictMultilineParsing() ? __strictCheck(line, code) : __lenientCheck(line));
    370
    371            } else if (isStrictReplyParsing()) {
    372                if (length == REPLY_CODE_LEN + 1) { // expecting some text
    373                    throw new MalformedServerReplyException("Truncated server reply: '" + line +"'");
    374                } else if (sep != ' ') {
    375                    throw new MalformedServerReplyException("Invalid server reply: '" + line +"'");
    376                }
    377            }
    378        } else if (isStrictReplyParsing()) {
    379            throw new MalformedServerReplyException("Truncated server reply: '" + line +"'");
    380        }
    381
    382        if (reportReply) {
    383            fireReplyReceived(_replyCode, getReplyString());
    384        }
    385
    386        if (_replyCode == FTPReply.SERVICE_NOT_AVAILABLE) {
    387            throw new FTPConnectionClosedException("FTP response 421 received.  Server closed connection.");
    388        }
    389    }
    390
    391    /**
    392     * Initiates control connections and gets initial reply.
    393     * Initializes {@link #_controlInput_} and {@link #_controlOutput_}.
    394     */
    395    @Override
    396    protected void _connectAction_() throws IOException
    397    {
    398        _connectAction_(null);
    399    }
    400
    401
    402    /**
    403     * Initiates control connections and gets initial reply.
    404     * Initializes {@link #_controlInput_} and {@link #_controlOutput_}.
    405     *
    406     * @param socketIsReader the reader to reuse (if non-null)
    407     * @throws IOException on error
    408     * @since 3.4
    409     */
    410    protected void _connectAction_(final Reader socketIsReader) throws IOException {
    411        super._connectAction_(); // sets up _input_ and _output_
    412        if(socketIsReader == null) {
    413            _controlInput_ =
    414                    new CRLFLineReader(new InputStreamReader(_input_, getControlEncoding()));
    415        } else {
    416            _controlInput_ = new CRLFLineReader(socketIsReader);
    417        }
    418        _controlOutput_ =
    419            new BufferedWriter(new OutputStreamWriter(_output_, getControlEncoding()));
    420        if (connectTimeout > 0) { // NET-385
    421            final int original = _socket_.getSoTimeout();
    422            _socket_.setSoTimeout(connectTimeout);
    423            try {
    424                __getReply();
    425                // If we received code 120, we have to fetch completion reply.
    426                if (FTPReply.isPositivePreliminary(_replyCode)) {
    427                    __getReply();
    428                }
    429            } catch (final SocketTimeoutException e) {
    430                final IOException ioe = new IOException("Timed out waiting for initial connect reply");
    431                ioe.initCause(e);
    432                throw ioe;
    433            } finally {
    434                _socket_.setSoTimeout(original);
    435            }
    436        } else {
    437            __getReply();
    438            // If we received code 120, we have to fetch completion reply.
    439            if (FTPReply.isPositivePreliminary(_replyCode)) {
    440                __getReply();
    441            }
    442        }
    443    }
    444
    445
    446    /**
    447     * Saves the character encoding to be used by the FTP control connection.
    448     * Some FTP servers require that commands be issued in a non-ASCII
    449     * encoding like UTF-8 so that file names with multi-byte character
    450     * representations (e.g, Big 8) can be specified.
    451     * <p>
    452     * Please note that this has to be set before the connection is established.
    453     *
    454     * @param encoding The new character encoding for the control connection.
    455     */
    456    public void setControlEncoding(final String encoding) {
    457        _controlEncoding = encoding;
    458    }
    459
    460
    461    /**
    462     * @return The character encoding used to communicate over the
    463     * control connection.
    464     */
    465    public String getControlEncoding() {
    466        return _controlEncoding;
    467    }
    468
    469
    470    /***
    471     * Closes the control connection to the FTP server and sets to null
    472     * some internal data so that the memory may be reclaimed by the
    473     * garbage collector.  The reply text and code information from the
    474     * last command is voided so that the memory it used may be reclaimed.
    475     * Also sets {@link #_controlInput_} and {@link #_controlOutput_} to null.
    476     *
    477     * @throws IOException If an error occurs while disconnecting.
    478     ***/
    479    @Override
    480    public void disconnect() throws IOException
    481    {
    482        super.disconnect();
    483        _controlInput_ = null;
    484        _controlOutput_ = null;
    485        _newReplyString = false;
    486        _replyString = null;
    487    }
    488
    489
    490    /***
    491     * Sends an FTP command to the server, waits for a reply and returns the
    492     * numerical response code.  After invocation, for more detailed
    493     * information, the actual reply text can be accessed by calling
    494     * {@link #getReplyString  getReplyString } or
    495     * {@link #getReplyStrings  getReplyStrings }.
    496     *
    497     * @param command  The text representation of the  FTP command to send.
    498     * @param args The arguments to the FTP command.  If this parameter is
    499     *             set to null, then the command is sent with no argument.
    500     * @return The integer value of the FTP reply code returned by the server
    501     *         in response to the command.
    502     * @throws FTPConnectionClosedException
    503     *      If the FTP server prematurely closes the connection as a result
    504     *      of the client being idle or some other reason causing the server
    505     *      to send FTP reply code 421.  This exception may be caught either
    506     *      as an IOException or independently as itself.
    507     * @throws IOException  If an I/O error occurs while either sending the
    508     *      command or receiving the server reply.
    509     ***/
    510    public int sendCommand(final String command, final String args) throws IOException
    511    {
    512        if (_controlOutput_ == null) {
    513            throw new IOException("Connection is not open");
    514        }
    515
    516        final String message = __buildMessage(command, args);
    517
    518        __send(message);
    519
    520        fireCommandSent(command, message);
    521
    522        __getReply();
    523        return _replyCode;
    524    }
    525
    526    private String __buildMessage(final String command, final String args) {
    527        final StringBuilder __commandBuffer = new StringBuilder();
    528
    529        __commandBuffer.append(command);
    530
    531        if (args != null)
    532        {
    533            __commandBuffer.append(' ');
    534            __commandBuffer.append(args);
    535        }
    536        __commandBuffer.append(SocketClient.NETASCII_EOL);
    537        return __commandBuffer.toString();
    538    }
    539
    540    private void __send(final String message) throws IOException,
    541            FTPConnectionClosedException, SocketException {
    542        try{
    543            _controlOutput_.write(message);
    544            _controlOutput_.flush();
    545        }
    546        catch (final SocketException e)
    547        {
    548            if (!isConnected())
    549            {
    550                throw new FTPConnectionClosedException("Connection unexpectedly closed.");
    551            }
    552            throw e;
    553        }
    554    }
    555
    556    /**
    557     * Send a noop and get the reply without reporting to the command listener.
    558     * Intended for use with keep-alive.
    559     *
    560     * @throws IOException on error
    561     * @since 3.0
    562     */
    563    protected void __noop() throws IOException {
    564        final String msg = __buildMessage(FTPCmd.NOOP.getCommand(), null);
    565        __send(msg);
    566        __getReplyNoReport(); // This may timeout
    567    }
    568
    569    /***
    570     * Sends an FTP command to the server, waits for a reply and returns the
    571     * numerical response code.  After invocation, for more detailed
    572     * information, the actual reply text can be accessed by calling
    573     * {@link #getReplyString  getReplyString } or
    574     * {@link #getReplyStrings  getReplyStrings }.
    575     *
    576     * @param command  The FTPCommand constant corresponding to the FTP command
    577     *                 to send.
    578     * @param args The arguments to the FTP command.  If this parameter is
    579     *             set to null, then the command is sent with no argument.
    580     * @return The integer value of the FTP reply code returned by the server
    581     *         in response to the command.
    582     * @throws FTPConnectionClosedException
    583     *      If the FTP server prematurely closes the connection as a result
    584     *      of the client being idle or some other reason causing the server
    585     *      to send FTP reply code 421.  This exception may be caught either
    586     *      as an IOException or independently as itself.
    587     * @throws IOException  If an I/O error occurs while either sending the
    588     *      command or receiving the server reply.
    589     * @deprecated (3.3) Use {@link #sendCommand(FTPCmd, String)} instead
    590     ***/
    591    @Deprecated
    592    public int sendCommand(final int command, final String args) throws IOException
    593    {
    594        return sendCommand(FTPCommand.getCommand(command), args);
    595    }
    596
    597    /**
    598     * Sends an FTP command to the server, waits for a reply and returns the
    599     * numerical response code.  After invocation, for more detailed
    600     * information, the actual reply text can be accessed by calling
    601     * {@link #getReplyString  getReplyString } or
    602     * {@link #getReplyStrings  getReplyStrings }.
    603     *
    604     * @param command  The FTPCmd enum corresponding to the FTP command
    605     *                 to send.
    606     * @return The integer value of the FTP reply code returned by the server
    607     *         in response to the command.
    608     * @throws FTPConnectionClosedException
    609     *      If the FTP server prematurely closes the connection as a result
    610     *      of the client being idle or some other reason causing the server
    611     *      to send FTP reply code 421.  This exception may be caught either
    612     *      as an IOException or independently as itself.
    613     * @throws IOException  If an I/O error occurs while either sending the
    614     *      command or receiving the server reply.
    615     * @since 3.3
    616     */
    617    public int sendCommand(final FTPCmd command)  throws IOException{
    618        return sendCommand(command, null);
    619    }
    620
    621    /**
    622     * Sends an FTP command to the server, waits for a reply and returns the
    623     * numerical response code.  After invocation, for more detailed
    624     * information, the actual reply text can be accessed by calling
    625     * {@link #getReplyString  getReplyString } or
    626     * {@link #getReplyStrings  getReplyStrings }.
    627     *
    628     * @param command  The FTPCmd enum corresponding to the FTP command
    629     *                 to send.
    630     * @param args The arguments to the FTP command.  If this parameter is
    631     *             set to null, then the command is sent with no argument.
    632     * @return The integer value of the FTP reply code returned by the server
    633     *         in response to the command.
    634     * @throws FTPConnectionClosedException
    635     *      If the FTP server prematurely closes the connection as a result
    636     *      of the client being idle or some other reason causing the server
    637     *      to send FTP reply code 421.  This exception may be caught either
    638     *      as an IOException or independently as itself.
    639     * @throws IOException  If an I/O error occurs while either sending the
    640     *      command or receiving the server reply.
    641     * @since 3.3
    642     */
    643    public int sendCommand(final FTPCmd command, final String args)  throws IOException{
    644        return sendCommand(command.getCommand(), args);
    645    }
    646
    647    /***
    648     * Sends an FTP command with no arguments to the server, waits for a
    649     * reply and returns the numerical response code.  After invocation, for
    650     * more detailed information, the actual reply text can be accessed by
    651     * calling {@link #getReplyString  getReplyString } or
    652     * {@link #getReplyStrings  getReplyStrings }.
    653     *
    654     * @param command  The text representation of the  FTP command to send.
    655     * @return The integer value of the FTP reply code returned by the server
    656     *         in response to the command.
    657     * @throws FTPConnectionClosedException
    658     *      If the FTP server prematurely closes the connection as a result
    659     *      of the client being idle or some other reason causing the server
    660     *      to send FTP reply code 421.  This exception may be caught either
    661     *      as an IOException or independently as itself.
    662     * @throws IOException  If an I/O error occurs while either sending the
    663     *      command or receiving the server reply.
    664     ***/
    665    public int sendCommand(final String command) throws IOException
    666    {
    667        return sendCommand(command, null);
    668    }
    669
    670
    671    /***
    672     * Sends an FTP command with no arguments to the server, waits for a
    673     * reply and returns the numerical response code.  After invocation, for
    674     * more detailed information, the actual reply text can be accessed by
    675     * calling {@link #getReplyString  getReplyString } or
    676     * {@link #getReplyStrings  getReplyStrings }.
    677     *
    678     * @param command  The FTPCommand constant corresponding to the FTP command
    679     *                 to send.
    680     * @return The integer value of the FTP reply code returned by the server
    681     *         in response to the command.
    682     * @throws FTPConnectionClosedException
    683     *      If the FTP server prematurely closes the connection as a result
    684     *      of the client being idle or some other reason causing the server
    685     *      to send FTP reply code 421.  This exception may be caught either
    686     *      as an IOException or independently as itself.
    687     * @throws IOException  If an I/O error occurs while either sending the
    688     *      command or receiving the server reply.
    689     ***/
    690    public int sendCommand(final int command) throws IOException
    691    {
    692        return sendCommand(command, null);
    693    }
    694
    695
    696    /***
    697     * Returns the integer value of the reply code of the last FTP reply.
    698     * You will usually only use this method after you connect to the
    699     * FTP server to check that the connection was successful since
    700     * <code> connect </code> is of type void.
    701     *
    702     * @return The integer value of the reply code of the last FTP reply.
    703     ***/
    704    public int getReplyCode()
    705    {
    706        return _replyCode;
    707    }
    708
    709    /***
    710     * Fetches a reply from the FTP server and returns the integer reply
    711     * code.  After calling this method, the actual reply text can be accessed
    712     * from either  calling {@link #getReplyString  getReplyString } or
    713     * {@link #getReplyStrings  getReplyStrings }.  Only use this
    714     * method if you are implementing your own FTP client or if you need to
    715     * fetch a secondary response from the FTP server.
    716     *
    717     * @return The integer value of the reply code of the fetched FTP reply.
    718     * @throws FTPConnectionClosedException
    719     *      If the FTP server prematurely closes the connection as a result
    720     *      of the client being idle or some other reason causing the server
    721     *      to send FTP reply code 421.  This exception may be caught either
    722     *      as an IOException or independently as itself.
    723     * @throws IOException  If an I/O error occurs while receiving the
    724     *                         server reply.
    725     ***/
    726    public int getReply() throws IOException
    727    {
    728        __getReply();
    729        return _replyCode;
    730    }
    731
    732
    733    /***
    734     * Returns the lines of text from the last FTP server response as an array
    735     * of strings, one entry per line.  The end of line markers of each are
    736     * stripped from each line.
    737     *
    738     * @return The lines of text from the last FTP response as an array.
    739     ***/
    740    public String[] getReplyStrings()
    741    {
    742        return _replyLines.toArray(new String[_replyLines.size()]);
    743    }
    744
    745    /***
    746     * Returns the entire text of the last FTP server response exactly
    747     * as it was received, including all end of line markers in NETASCII
    748     * format.
    749     *
    750     * @return The entire text from the last FTP response as a String.
    751     ***/
    752    public String getReplyString()
    753    {
    754        StringBuilder buffer;
    755
    756        if (!_newReplyString) {
    757            return _replyString;
    758        }
    759
    760        buffer = new StringBuilder(256);
    761
    762        for (final String line : _replyLines) {
    763                buffer.append(line);
    764                buffer.append(SocketClient.NETASCII_EOL);
    765        }
    766
    767         _newReplyString = false;
    768
    769        return _replyString = buffer.toString();
    770    }
    771
    772
    773    /***
    774     * A convenience method to send the FTP USER command to the server,
    775     * receive the reply, and return the reply code.
    776     *
    777     * @param username  The username to login under.
    778     * @return The reply code received from the server.
    779     * @throws FTPConnectionClosedException
    780     *      If the FTP server prematurely closes the connection as a result
    781     *      of the client being idle or some other reason causing the server
    782     *      to send FTP reply code 421.  This exception may be caught either
    783     *      as an IOException or independently as itself.
    784     * @throws IOException  If an I/O error occurs while either sending the
    785     *      command or receiving the server reply.
    786     ***/
    787    public int user(final String username) throws IOException
    788    {
    789        return sendCommand(FTPCmd.USER, username);
    790    }
    791
    792    /**
    793     * A convenience method to send the FTP PASS command to the server,
    794     * receive the reply, and return the reply code.
    795     * @param password The plain text password of the username being logged into.
    796     * @return The reply code received from the server.
    797     * @throws FTPConnectionClosedException
    798     *      If the FTP server prematurely closes the connection as a result
    799     *      of the client being idle or some other reason causing the server
    800     *      to send FTP reply code 421.  This exception may be caught either
    801     *      as an IOException or independently as itself.
    802     * @throws IOException  If an I/O error occurs while either sending the
    803     *      command or receiving the server reply.
    804     */
    805    public int pass(final String password) throws IOException
    806    {
    807        return sendCommand(FTPCmd.PASS, password);
    808    }
    809
    810    /***
    811     * A convenience method to send the FTP ACCT command to the server,
    812     * receive the reply, and return the reply code.
    813     *
    814     * @param account  The account name to access.
    815     * @return The reply code received from the server.
    816     * @throws FTPConnectionClosedException
    817     *      If the FTP server prematurely closes the connection as a result
    818     *      of the client being idle or some other reason causing the server
    819     *      to send FTP reply code 421.  This exception may be caught either
    820     *      as an IOException or independently as itself.
    821     * @throws IOException  If an I/O error occurs while either sending the
    822     *      command or receiving the server reply.
    823     ***/
    824    public int acct(final String account) throws IOException
    825    {
    826        return sendCommand(FTPCmd.ACCT, account);
    827    }
    828
    829
    830    /***
    831     * A convenience method to send the FTP ABOR command to the server,
    832     * receive the reply, and return the reply code.
    833     *
    834     * @return The reply code received from the server.
    835     * @throws FTPConnectionClosedException
    836     *      If the FTP server prematurely closes the connection as a result
    837     *      of the client being idle or some other reason causing the server
    838     *      to send FTP reply code 421.  This exception may be caught either
    839     *      as an IOException or independently as itself.
    840     * @throws IOException  If an I/O error occurs while either sending the
    841     *      command or receiving the server reply.
    842     ***/
    843    public int abor() throws IOException
    844    {
    845        return sendCommand(FTPCmd.ABOR);
    846    }
    847
    848    /***
    849     * A convenience method to send the FTP CWD command to the server,
    850     * receive the reply, and return the reply code.
    851     *
    852     * @param directory The new working directory.
    853     * @return The reply code received from the server.
    854     * @throws FTPConnectionClosedException
    855     *      If the FTP server prematurely closes the connection as a result
    856     *      of the client being idle or some other reason causing the server
    857     *      to send FTP reply code 421.  This exception may be caught either
    858     *      as an IOException or independently as itself.
    859     * @throws IOException  If an I/O error occurs while either sending the
    860     *      command or receiving the server reply.
    861     ***/
    862    public int cwd(final String directory) throws IOException
    863    {
    864        return sendCommand(FTPCmd.CWD, directory);
    865    }
    866
    867    /***
    868     * A convenience method to send the FTP CDUP command to the server,
    869     * receive the reply, and return the reply code.
    870     *
    871     * @return The reply code received from the server.
    872     * @throws FTPConnectionClosedException
    873     *      If the FTP server prematurely closes the connection as a result
    874     *      of the client being idle or some other reason causing the server
    875     *      to send FTP reply code 421.  This exception may be caught either
    876     *      as an IOException or independently as itself.
    877     * @throws IOException  If an I/O error occurs while either sending the
    878     *      command or receiving the server reply.
    879     ***/
    880    public int cdup() throws IOException
    881    {
    882        return sendCommand(FTPCmd.CDUP);
    883    }
    884
    885    /***
    886     * A convenience method to send the FTP QUIT command to the server,
    887     * receive the reply, and return the reply code.
    888     *
    889     * @return The reply code received from the server.
    890     * @throws FTPConnectionClosedException
    891     *      If the FTP server prematurely closes the connection as a result
    892     *      of the client being idle or some other reason causing the server
    893     *      to send FTP reply code 421.  This exception may be caught either
    894     *      as an IOException or independently as itself.
    895     * @throws IOException  If an I/O error occurs while either sending the
    896     *      command or receiving the server reply.
    897     ***/
    898    public int quit() throws IOException
    899    {
    900        return sendCommand(FTPCmd.QUIT);
    901    }
    902
    903    /***
    904     * A convenience method to send the FTP REIN command to the server,
    905     * receive the reply, and return the reply code.
    906     *
    907     * @return The reply code received from the server.
    908     * @throws FTPConnectionClosedException
    909     *      If the FTP server prematurely closes the connection as a result
    910     *      of the client being idle or some other reason causing the server
    911     *      to send FTP reply code 421.  This exception may be caught either
    912     *      as an IOException or independently as itself.
    913     * @throws IOException  If an I/O error occurs while either sending the
    914     *      command or receiving the server reply.
    915     ***/
    916    public int rein() throws IOException
    917    {
    918        return sendCommand(FTPCmd.REIN);
    919    }
    920
    921    /***
    922     * A convenience method to send the FTP SMNT command to the server,
    923     * receive the reply, and return the reply code.
    924     *
    925     * @param dir  The directory name.
    926     * @return The reply code received from the server.
    927     * @throws FTPConnectionClosedException
    928     *      If the FTP server prematurely closes the connection as a result
    929     *      of the client being idle or some other reason causing the server
    930     *      to send FTP reply code 421.  This exception may be caught either
    931     *      as an IOException or independently as itself.
    932     * @throws IOException  If an I/O error occurs while either sending the
    933     *      command or receiving the server reply.
    934     ***/
    935    public int smnt(final String dir) throws IOException
    936    {
    937        return sendCommand(FTPCmd.SMNT, dir);
    938    }
    939
    940    /***
    941     * A convenience method to send the FTP PORT command to the server,
    942     * receive the reply, and return the reply code.
    943     *
    944     * @param host  The host owning the port.
    945     * @param port  The new port.
    946     * @return The reply code received from the server.
    947     * @throws FTPConnectionClosedException
    948     *      If the FTP server prematurely closes the connection as a result
    949     *      of the client being idle or some other reason causing the server
    950     *      to send FTP reply code 421.  This exception may be caught either
    951     *      as an IOException or independently as itself.
    952     * @throws IOException  If an I/O error occurs while either sending the
    953     *      command or receiving the server reply.
    954     ***/
    955    public int port(final InetAddress host, final int port) throws IOException
    956    {
    957        int num;
    958        final StringBuilder info = new StringBuilder(24);
    959
    960        info.append(host.getHostAddress().replace('.', ','));
    961        num = port >>> 8;
    962        info.append(',');
    963        info.append(num);
    964        info.append(',');
    965        num = port & 0xff;
    966        info.append(num);
    967
    968        return sendCommand(FTPCmd.PORT, info.toString());
    969    }
    970
    971    /***
    972     * A convenience method to send the FTP EPRT command to the server,
    973     * receive the reply, and return the reply code.
    974     *
    975     * Examples:
    976     * <ul>
    977     * <li>EPRT |1|132.235.1.2|6275|</li>
    978     * <li>EPRT |2|1080::8:800:200C:417A|5282|</li>
    979     * </ul>
    980     *
    981     * @see "http://www.faqs.org/rfcs/rfc2428.html"
    982     *
    983     * @param host  The host owning the port.
    984     * @param port  The new port.
    985     * @return The reply code received from the server.
    986     * @throws FTPConnectionClosedException
    987     *      If the FTP server prematurely closes the connection as a result
    988     *      of the client being idle or some other reason causing the server
    989     *      to send FTP reply code 421.  This exception may be caught either
    990     *      as an IOException or independently as itself.
    991     * @throws IOException  If an I/O error occurs while either sending the
    992     *      command or receiving the server reply.
    993     * @since 2.2
    994     ***/
    995    public int eprt(final InetAddress host, final int port) throws IOException
    996    {
    997        int num;
    998        final StringBuilder info = new StringBuilder();
    999        String h;
    1000
    1001        // If IPv6, trim the zone index
    1002        h = host.getHostAddress();
    1003        num = h.indexOf('%');
    1004        if (num > 0) {
    1005            h = h.substring(0, num);
    1006        }
    1007
    1008        info.append("|");
    1009
    1010        if (host instanceof Inet4Address) {
    1011            info.append("1");
    1012        } else if (host instanceof Inet6Address) {
    1013            info.append("2");
    1014        }
    1015        info.append("|");
    1016        info.append(h);
    1017        info.append("|");
    1018        info.append(port);
    1019        info.append("|");
    1020
    1021        return sendCommand(FTPCmd.EPRT, info.toString());
    1022    }
    1023
    1024    /***
    1025     * A convenience method to send the FTP PASV command to the server,
    1026     * receive the reply, and return the reply code.  Remember, it's up
    1027     * to you to interpret the reply string containing the host/port
    1028     * information.
    1029     *
    1030     * @return The reply code received from the server.
    1031     * @throws FTPConnectionClosedException
    1032     *      If the FTP server prematurely closes the connection as a result
    1033     *      of the client being idle or some other reason causing the server
    1034     *      to send FTP reply code 421.  This exception may be caught either
    1035     *      as an IOException or independently as itself.
    1036     * @throws IOException  If an I/O error occurs while either sending the
    1037     *      command or receiving the server reply.
    1038     ***/
    1039    public int pasv() throws IOException
    1040    {
    1041        return sendCommand(FTPCmd.PASV);
    1042    }
    1043
    1044     /***
    1045     * A convenience method to send the FTP EPSV command to the server,
    1046     * receive the reply, and return the reply code.  Remember, it's up
    1047     * to you to interpret the reply string containing the host/port
    1048     * information.
    1049     *
    1050     * @return The reply code received from the server.
    1051     * @throws FTPConnectionClosedException
    1052     *      If the FTP server prematurely closes the connection as a result
    1053     *      of the client being idle or some other reason causing the server
    1054     *      to send FTP reply code 421.  This exception may be caught either
    1055     *      as an IOException or independently as itself.
    1056     * @throws IOException  If an I/O error occurs while either sending the
    1057     *      command or receiving the server reply.
    1058     * @since 2.2
    1059     ***/
    1060    public int epsv() throws IOException
    1061    {
    1062        return sendCommand(FTPCmd.EPSV);
    1063    }
    1064
    1065    /**
    1066     * A convenience method to send the FTP TYPE command for text files
    1067     * to the server, receive the reply, and return the reply code.
    1068     * @param fileType  The type of the file (one of the <code>FILE_TYPE</code>
    1069     *              constants).
    1070     * @param formatOrByteSize  The format of the file (one of the
    1071     *              <code>_FORMAT</code> constants.  In the case of
    1072     *              <code>LOCAL_FILE_TYPE</code>, the byte size.
    1073     * @return The reply code received from the server.
    1074     * @throws FTPConnectionClosedException
    1075     *      If the FTP server prematurely closes the connection as a result
    1076     *      of the client being idle or some other reason causing the server
    1077     *      to send FTP reply code 421.  This exception may be caught either
    1078     *      as an IOException or independently as itself.
    1079     * @throws IOException  If an I/O error occurs while either sending the
    1080     *      command or receiving the server reply.
    1081     */
    1082    public int type(final int fileType, final int formatOrByteSize) throws IOException
    1083    {
    1084        final StringBuilder arg = new StringBuilder();
    1085
    1086        arg.append(modes.charAt(fileType));
    1087        arg.append(' ');
    1088        if (fileType == LOCAL_FILE_TYPE) {
    1089            arg.append(formatOrByteSize);
    1090        } else {
    1091            arg.append(modes.charAt(formatOrByteSize));
    1092        }
    1093
    1094        return sendCommand(FTPCmd.TYPE, arg.toString());
    1095    }
    1096
    1097
    1098    /**
    1099     * A convenience method to send the FTP TYPE command to the server,
    1100     * receive the reply, and return the reply code.
    1101     *
    1102     * @param fileType  The type of the file (one of the <code>FILE_TYPE</code>
    1103     *              constants).
    1104     * @return The reply code received from the server.
    1105     * @throws FTPConnectionClosedException
    1106     *      If the FTP server prematurely closes the connection as a result
    1107     *      of the client being idle or some other reason causing the server
    1108     *      to send FTP reply code 421.  This exception may be caught either
    1109     *      as an IOException or independently as itself.
    1110     * @throws IOException  If an I/O error occurs while either sending the
    1111     *      command or receiving the server reply.
    1112     */
    1113    public int type(final int fileType) throws IOException
    1114    {
    1115        return sendCommand(FTPCmd.TYPE,
    1116                           modes.substring(fileType, fileType + 1));
    1117    }
    1118
    1119    /***
    1120     * A convenience method to send the FTP STRU command to the server,
    1121     * receive the reply, and return the reply code.
    1122     *
    1123     * @param structure  The structure of the file (one of the
    1124     *         <code>_STRUCTURE</code> constants).
    1125     * @return The reply code received from the server.
    1126     * @throws FTPConnectionClosedException
    1127     *      If the FTP server prematurely closes the connection as a result
    1128     *      of the client being idle or some other reason causing the server
    1129     *      to send FTP reply code 421.  This exception may be caught either
    1130     *      as an IOException or independently as itself.
    1131     * @throws IOException  If an I/O error occurs while either sending the
    1132     *      command or receiving the server reply.
    1133     ***/
    1134    public int stru(final int structure) throws IOException
    1135    {
    1136        return sendCommand(FTPCmd.STRU,
    1137                           modes.substring(structure, structure + 1));
    1138    }
    1139
    1140    /***
    1141     * A convenience method to send the FTP MODE command to the server,
    1142     * receive the reply, and return the reply code.
    1143     *
    1144     * @param mode  The transfer mode to use (one of the
    1145     *         <code>TRANSFER_MODE</code> constants).
    1146     * @return The reply code received from the server.
    1147     * @throws FTPConnectionClosedException
    1148     *      If the FTP server prematurely closes the connection as a result
    1149     *      of the client being idle or some other reason causing the server
    1150     *      to send FTP reply code 421.  This exception may be caught either
    1151     *      as an IOException or independently as itself.
    1152     * @throws IOException  If an I/O error occurs while either sending the
    1153     *      command or receiving the server reply.
    1154     ***/
    1155    public int mode(final int mode) throws IOException
    1156    {
    1157        return sendCommand(FTPCmd.MODE,
    1158                           modes.substring(mode, mode + 1));
    1159    }
    1160
    1161    /***
    1162     * A convenience method to send the FTP RETR command to the server,
    1163     * receive the reply, and return the reply code.  Remember, it is up
    1164     * to you to manage the data connection.  If you don't need this low
    1165     * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
    1166     * , which will handle all low level details for you.
    1167     *
    1168     * @param pathname  The pathname of the file to retrieve.
    1169     * @return The reply code received from the server.
    1170     * @throws FTPConnectionClosedException
    1171     *      If the FTP server prematurely closes the connection as a result
    1172     *      of the client being idle or some other reason causing the server
    1173     *      to send FTP reply code 421.  This exception may be caught either
    1174     *      as an IOException or independently as itself.
    1175     * @throws IOException  If an I/O error occurs while either sending the
    1176     *      command or receiving the server reply.
    1177     ***/
    1178    public int retr(final String pathname) throws IOException
    1179    {
    1180        return sendCommand(FTPCmd.RETR, pathname);
    1181    }
    1182
    1183    /***
    1184     * A convenience method to send the FTP STOR command to the server,
    1185     * receive the reply, and return the reply code.  Remember, it is up
    1186     * to you to manage the data connection.  If you don't need this low
    1187     * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
    1188     * , which will handle all low level details for you.
    1189     *
    1190     * @param pathname  The pathname to use for the file when stored at
    1191     *                  the remote end of the transfer.
    1192     * @return The reply code received from the server.
    1193     * @throws FTPConnectionClosedException
    1194     *      If the FTP server prematurely closes the connection as a result
    1195     *      of the client being idle or some other reason causing the server
    1196     *      to send FTP reply code 421.  This exception may be caught either
    1197     *      as an IOException or independently as itself.
    1198     * @throws IOException  If an I/O error occurs while either sending the
    1199     *      command or receiving the server reply.
    1200     ***/
    1201    public int stor(final String pathname) throws IOException
    1202    {
    1203        return sendCommand(FTPCmd.STOR, pathname);
    1204    }
    1205
    1206    /***
    1207     * A convenience method to send the FTP STOU command to the server,
    1208     * receive the reply, and return the reply code.  Remember, it is up
    1209     * to you to manage the data connection.  If you don't need this low
    1210     * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
    1211     * , which will handle all low level details for you.
    1212     *
    1213     * @return The reply code received from the server.
    1214     * @throws FTPConnectionClosedException
    1215     *      If the FTP server prematurely closes the connection as a result
    1216     *      of the client being idle or some other reason causing the server
    1217     *      to send FTP reply code 421.  This exception may be caught either
    1218     *      as an IOException or independently as itself.
    1219     * @throws IOException  If an I/O error occurs while either sending the
    1220     *      command or receiving the server reply.
    1221     ***/
    1222    public int stou() throws IOException
    1223    {
    1224        return sendCommand(FTPCmd.STOU);
    1225    }
    1226
    1227    /***
    1228     * A convenience method to send the FTP STOU command to the server,
    1229     * receive the reply, and return the reply code.  Remember, it is up
    1230     * to you to manage the data connection.  If you don't need this low
    1231     * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
    1232     * , which will handle all low level details for you.
    1233     * @param pathname  The base pathname to use for the file when stored at
    1234     *                  the remote end of the transfer.  Some FTP servers
    1235     *                  require this.
    1236     * @return The reply code received from the server.
    1237     * @throws FTPConnectionClosedException
    1238     *      If the FTP server prematurely closes the connection as a result
    1239     *      of the client being idle or some other reason causing the server
    1240     *      to send FTP reply code 421.  This exception may be caught either
    1241     *      as an IOException or independently as itself.
    1242     * @throws IOException  If an I/O error occurs while either sending the
    1243     *      command or receiving the server reply.
    1244     */
    1245    public int stou(final String pathname) throws IOException
    1246    {
    1247        return sendCommand(FTPCmd.STOU, pathname);
    1248    }
    1249
    1250    /***
    1251     * A convenience method to send the FTP APPE command to the server,
    1252     * receive the reply, and return the reply code.  Remember, it is up
    1253     * to you to manage the data connection.  If you don't need this low
    1254     * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
    1255     * , which will handle all low level details for you.
    1256     *
    1257     * @param pathname  The pathname to use for the file when stored at
    1258     *                  the remote end of the transfer.
    1259     * @return The reply code received from the server.
    1260     * @throws FTPConnectionClosedException
    1261     *      If the FTP server prematurely closes the connection as a result
    1262     *      of the client being idle or some other reason causing the server
    1263     *      to send FTP reply code 421.  This exception may be caught either
    1264     *      as an IOException or independently as itself.
    1265     * @throws IOException  If an I/O error occurs while either sending the
    1266     *      command or receiving the server reply.
    1267     ***/
    1268    public int appe(final String pathname) throws IOException
    1269    {
    1270        return sendCommand(FTPCmd.APPE, pathname);
    1271    }
    1272
    1273    /***
    1274     * A convenience method to send the FTP ALLO command to the server,
    1275     * receive the reply, and return the reply code.
    1276     *
    1277     * @param bytes The number of bytes to allocate.
    1278     * @return The reply code received from the server.
    1279     * @throws FTPConnectionClosedException
    1280     *      If the FTP server prematurely closes the connection as a result
    1281     *      of the client being idle or some other reason causing the server
    1282     *      to send FTP reply code 421.  This exception may be caught either
    1283     *      as an IOException or independently as itself.
    1284     * @throws IOException  If an I/O error occurs while either sending the
    1285     *      command or receiving the server reply.
    1286     ***/
    1287    public int allo(final int bytes) throws IOException
    1288    {
    1289        return sendCommand(FTPCmd.ALLO, Integer.toString(bytes));
    1290    }
    1291
    1292    /***
    1293     * A convenience method to send the FTP ALLO command to the server,
    1294     * receive the reply, and return the reply code.
    1295     *
    1296     * @param bytes The number of bytes to allocate.
    1297     * @return The reply code received from the server.
    1298     * @throws FTPConnectionClosedException
    1299     *      If the FTP server prematurely closes the connection as a result
    1300     *      of the client being idle or some other reason causing the server
    1301     *      to send FTP reply code 421.  This exception may be caught either
    1302     *      as an IOException or independently as itself.
    1303     * @throws IOException  If an I/O error occurs while either sending the
    1304     *      command or receiving the server reply.
    1305     ***/
    1306    public int allo(final long bytes) throws IOException
    1307    {
    1308        return sendCommand(FTPCmd.ALLO, Long.toString(bytes));
    1309    }
    1310
    1311    /**
    1312     * A convenience method to send the FTP FEAT command to the server, receive the reply,
    1313     * and return the reply code.
    1314     * @return The reply code received by the server
    1315     * @throws IOException  If an I/O error occurs while either sending the
    1316     *      command or receiving the server reply.
    1317     * @since 2.2
    1318     */
    1319    public int feat() throws IOException
    1320    {
    1321        return sendCommand(FTPCmd.FEAT);
    1322    }
    1323
    1324    /***
    1325     * A convenience method to send the FTP ALLO command to the server,
    1326     * receive the reply, and return the reply code.
    1327     *
    1328     * @param bytes The number of bytes to allocate.
    1329     * @param recordSize  The size of a record.
    1330     * @return The reply code received from the server.
    1331     * @throws FTPConnectionClosedException
    1332     *      If the FTP server prematurely closes the connection as a result
    1333     *      of the client being idle or some other reason causing the server
    1334     *      to send FTP reply code 421.  This exception may be caught either
    1335     *      as an IOException or independently as itself.
    1336     * @throws IOException  If an I/O error occurs while either sending the
    1337     *      command or receiving the server reply.
    1338     ***/
    1339    public int allo(final int bytes, final int recordSize) throws IOException
    1340    {
    1341        return sendCommand(FTPCmd.ALLO, Integer.toString(bytes) + " R " +
    1342                           Integer.toString(recordSize));
    1343    }
    1344
    1345    /***
    1346     * A convenience method to send the FTP ALLO command to the server,
    1347     * receive the reply, and return the reply code.
    1348     *
    1349     * @param bytes The number of bytes to allocate.
    1350     * @param recordSize  The size of a record.
    1351     * @return The reply code received from the server.
    1352     * @throws FTPConnectionClosedException
    1353     *      If the FTP server prematurely closes the connection as a result
    1354     *      of the client being idle or some other reason causing the server
    1355     *      to send FTP reply code 421.  This exception may be caught either
    1356     *      as an IOException or independently as itself.
    1357     * @throws IOException  If an I/O error occurs while either sending the
    1358     *      command or receiving the server reply.
    1359     ***/
    1360    public int allo(final long bytes, final int recordSize) throws IOException
    1361    {
    1362        return sendCommand(FTPCmd.ALLO, Long.toString(bytes) + " R " +
    1363                           Integer.toString(recordSize));
    1364    }
    1365
    1366    /***
    1367     * A convenience method to send the FTP REST command to the server,
    1368     * receive the reply, and return the reply code.
    1369     *
    1370     * @param marker The marker at which to restart a transfer.
    1371     * @return The reply code received from the server.
    1372     * @throws FTPConnectionClosedException
    1373     *      If the FTP server prematurely closes the connection as a result
    1374     *      of the client being idle or some other reason causing the server
    1375     *      to send FTP reply code 421.  This exception may be caught either
    1376     *      as an IOException or independently as itself.
    1377     * @throws IOException  If an I/O error occurs while either sending the
    1378     *      command or receiving the server reply.
    1379     ***/
    1380    public int rest(final String marker) throws IOException
    1381    {
    1382        return sendCommand(FTPCmd.REST, marker);
    1383    }
    1384
    1385
    1386    /**
    1387     * @param file name of file
    1388     * @return the status
    1389     * @throws IOException on error
    1390     * @since 2.0
    1391     **/
    1392    public int mdtm(final String file) throws IOException
    1393    {
    1394        return sendCommand(FTPCmd.MDTM, file);
    1395    }
    1396
    1397
    1398    /**
    1399     * A convenience method to send the FTP MFMT command to the server,
    1400     * receive the reply, and return the reply code.
    1401     *
    1402     * @param pathname The pathname for which mtime is to be changed
    1403     * @param timeval Timestamp in <code>YYYYMMDDhhmmss</code> format
    1404     * @return The reply code received from the server.
    1405     * @throws FTPConnectionClosedException
    1406     *      If the FTP server prematurely closes the connection as a result
    1407     *      of the client being idle or some other reason causing the server
    1408     *      to send FTP reply code 421.  This exception may be caught either
    1409     *      as an IOException or independently as itself.
    1410     * @throws IOException  If an I/O error occurs while either sending the
    1411     *      command or receiving the server reply.
    1412     * @since 2.2
    1413     * @see <a href="http://tools.ietf.org/html/draft-somers-ftp-mfxx-04">http://tools.ietf.org/html/draft-somers-ftp-mfxx-04</a>
    1414     **/
    1415    public int mfmt(final String pathname, final String timeval) throws IOException
    1416    {
    1417        return sendCommand(FTPCmd.MFMT, timeval + " " + pathname);
    1418    }
    1419
    1420
    1421    /***
    1422     * A convenience method to send the FTP RNFR command to the server,
    1423     * receive the reply, and return the reply code.
    1424     *
    1425     * @param pathname The pathname to rename from.
    1426     * @return The reply code received from the server.
    1427     * @throws FTPConnectionClosedException
    1428     *      If the FTP server prematurely closes the connection as a result
    1429     *      of the client being idle or some other reason causing the server
    1430     *      to send FTP reply code 421.  This exception may be caught either
    1431     *      as an IOException or independently as itself.
    1432     * @throws IOException  If an I/O error occurs while either sending the
    1433     *      command or receiving the server reply.
    1434     ***/
    1435    public int rnfr(final String pathname) throws IOException
    1436    {
    1437        return sendCommand(FTPCmd.RNFR, pathname);
    1438    }
    1439
    1440    /***
    1441     * A convenience method to send the FTP RNTO command to the server,
    1442     * receive the reply, and return the reply code.
    1443     *
    1444     * @param pathname The pathname to rename to
    1445     * @return The reply code received from the server.
    1446     * @throws FTPConnectionClosedException
    1447     *      If the FTP server prematurely closes the connection as a result
    1448     *      of the client being idle or some other reason causing the server
    1449     *      to send FTP reply code 421.  This exception may be caught either
    1450     *      as an IOException or independently as itself.
    1451     * @throws IOException  If an I/O error occurs while either sending the
    1452     *      command or receiving the server reply.
    1453     ***/
    1454    public int rnto(final String pathname) throws IOException
    1455    {
    1456        return sendCommand(FTPCmd.RNTO, pathname);
    1457    }
    1458
    1459    /***
    1460     * A convenience method to send the FTP DELE command to the server,
    1461     * receive the reply, and return the reply code.
    1462     *
    1463     * @param pathname The pathname to delete.
    1464     * @return The reply code received from the server.
    1465     * @throws FTPConnectionClosedException
    1466     *      If the FTP server prematurely closes the connection as a result
    1467     *      of the client being idle or some other reason causing the server
    1468     *      to send FTP reply code 421.  This exception may be caught either
    1469     *      as an IOException or independently as itself.
    1470     * @throws IOException  If an I/O error occurs while either sending the
    1471     *      command or receiving the server reply.
    1472     ***/
    1473    public int dele(final String pathname) throws IOException
    1474    {
    1475        return sendCommand(FTPCmd.DELE, pathname);
    1476    }
    1477
    1478    /***
    1479     * A convenience method to send the FTP RMD command to the server,
    1480     * receive the reply, and return the reply code.
    1481     *
    1482     * @param pathname The pathname of the directory to remove.
    1483     * @return The reply code received from the server.
    1484     * @throws FTPConnectionClosedException
    1485     *      If the FTP server prematurely closes the connection as a result
    1486     *      of the client being idle or some other reason causing the server
    1487     *      to send FTP reply code 421.  This exception may be caught either
    1488     *      as an IOException or independently as itself.
    1489     * @throws IOException  If an I/O error occurs while either sending the
    1490     *      command or receiving the server reply.
    1491     ***/
    1492    public int rmd(final String pathname) throws IOException
    1493    {
    1494        return sendCommand(FTPCmd.RMD, pathname);
    1495    }
    1496
    1497    /***
    1498     * A convenience method to send the FTP MKD command to the server,
    1499     * receive the reply, and return the reply code.
    1500     *
    1501     * @param pathname The pathname of the new directory to create.
    1502     * @return The reply code received from the server.
    1503     * @throws FTPConnectionClosedException
    1504     *      If the FTP server prematurely closes the connection as a result
    1505     *      of the client being idle or some other reason causing the server
    1506     *      to send FTP reply code 421.  This exception may be caught either
    1507     *      as an IOException or independently as itself.
    1508     * @throws IOException  If an I/O error occurs while either sending the
    1509     *      command or receiving the server reply.
    1510     ***/
    1511    public int mkd(final String pathname) throws IOException
    1512    {
    1513        return sendCommand(FTPCmd.MKD, pathname);
    1514    }
    1515
    1516    /***
    1517     * A convenience method to send the FTP PWD command to the server,
    1518     * receive the reply, and return the reply code.
    1519     *
    1520     * @return The reply code received from the server.
    1521     * @throws FTPConnectionClosedException
    1522     *      If the FTP server prematurely closes the connection as a result
    1523     *      of the client being idle or some other reason causing the server
    1524     *      to send FTP reply code 421.  This exception may be caught either
    1525     *      as an IOException or independently as itself.
    1526     * @throws IOException  If an I/O error occurs while either sending the
    1527     *      command or receiving the server reply.
    1528     ***/
    1529    public int pwd() throws IOException
    1530    {
    1531        return sendCommand(FTPCmd.PWD);
    1532    }
    1533
    1534    /***
    1535     * A convenience method to send the FTP LIST command to the server,
    1536     * receive the reply, and return the reply code.  Remember, it is up
    1537     * to you to manage the data connection.  If you don't need this low
    1538     * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
    1539     * , which will handle all low level details for you.
    1540     *
    1541     * @return The reply code received from the server.
    1542     * @throws FTPConnectionClosedException
    1543     *      If the FTP server prematurely closes the connection as a result
    1544     *      of the client being idle or some other reason causing the server
    1545     *      to send FTP reply code 421.  This exception may be caught either
    1546     *      as an IOException or independently as itself.
    1547     * @throws IOException  If an I/O error occurs while either sending the
    1548     *      command or receiving the server reply.
    1549     ***/
    1550    public int list() throws IOException
    1551    {
    1552        return sendCommand(FTPCmd.LIST);
    1553    }
    1554
    1555    /***
    1556     * A convenience method to send the FTP LIST command to the server,
    1557     * receive the reply, and return the reply code.  Remember, it is up
    1558     * to you to manage the data connection.  If you don't need this low
    1559     * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
    1560     * , which will handle all low level details for you.
    1561     *
    1562     * @param pathname  The pathname to list,
    1563     * may be {@code null} in which case the command is sent with no parameters
    1564     * @return The reply code received from the server.
    1565     * @throws FTPConnectionClosedException
    1566     *      If the FTP server prematurely closes the connection as a result
    1567     *      of the client being idle or some other reason causing the server
    1568     *      to send FTP reply code 421.  This exception may be caught either
    1569     *      as an IOException or independently as itself.
    1570     * @throws IOException  If an I/O error occurs while either sending the
    1571     *      command or receiving the server reply.
    1572     ***/
    1573    public int list(final String pathname) throws IOException
    1574    {
    1575        return sendCommand(FTPCmd.LIST, pathname);
    1576    }
    1577
    1578    /**
    1579     * A convenience method to send the FTP MLSD command to the server,
    1580     * receive the reply, and return the reply code.  Remember, it is up
    1581     * to you to manage the data connection.  If you don't need this low
    1582     * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
    1583     * , which will handle all low level details for you.
    1584     *
    1585     * @return The reply code received from the server.
    1586     * @throws FTPConnectionClosedException
    1587     *      If the FTP server prematurely closes the connection as a result
    1588     *      of the client being idle or some other reason causing the server
    1589     *      to send FTP reply code 421.  This exception may be caught either
    1590     *      as an IOException or independently as itself.
    1591     * @throws IOException  If an I/O error occurs while either sending the
    1592     *      command or receiving the server reply.
    1593     * @since 3.0
    1594     */
    1595    public int mlsd() throws IOException
    1596    {
    1597        return sendCommand(FTPCmd.MLSD);
    1598    }
    1599
    1600    /**
    1601     * A convenience method to send the FTP MLSD command to the server,
    1602     * receive the reply, and return the reply code.  Remember, it is up
    1603     * to you to manage the data connection.  If you don't need this low
    1604     * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
    1605     * , which will handle all low level details for you.
    1606     *
    1607     * @param path the path to report on
    1608     * @return The reply code received from the server,
    1609     * may be {@code null} in which case the command is sent with no parameters
    1610     * @throws FTPConnectionClosedException
    1611     *      If the FTP server prematurely closes the connection as a result
    1612     *      of the client being idle or some other reason causing the server
    1613     *      to send FTP reply code 421.  This exception may be caught either
    1614     *      as an IOException or independently as itself.
    1615     * @throws IOException  If an I/O error occurs while either sending the
    1616     *      command or receiving the server reply.
    1617     * @since 3.0
    1618     */
    1619    public int mlsd(final String path) throws IOException
    1620    {
    1621        return sendCommand(FTPCmd.MLSD, path);
    1622    }
    1623
    1624    /**
    1625     * A convenience method to send the FTP MLST command to the server,
    1626     * receive the reply, and return the reply code.  Remember, it is up
    1627     * to you to manage the data connection.  If you don't need this low
    1628     * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
    1629     * , which will handle all low level details for you.
    1630     *
    1631     * @return The reply code received from the server.
    1632     * @throws FTPConnectionClosedException
    1633     *      If the FTP server prematurely closes the connection as a result
    1634     *      of the client being idle or some other reason causing the server
    1635     *      to send FTP reply code 421.  This exception may be caught either
    1636     *      as an IOException or independently as itself.
    1637     * @throws IOException  If an I/O error occurs while either sending the
    1638     *      command or receiving the server reply.
    1639     * @since 3.0
    1640     */
    1641    public int mlst() throws IOException
    1642    {
    1643        return sendCommand(FTPCmd.MLST);
    1644    }
    1645
    1646    /**
    1647     * A convenience method to send the FTP MLST command to the server,
    1648     * receive the reply, and return the reply code.  Remember, it is up
    1649     * to you to manage the data connection.  If you don't need this low
    1650     * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
    1651     * , which will handle all low level details for you.
    1652     *
    1653     * @param path the path to report on
    1654     * @return The reply code received from the server,
    1655     * may be {@code null} in which case the command is sent with no parameters
    1656     * @throws FTPConnectionClosedException
    1657     *      If the FTP server prematurely closes the connection as a result
    1658     *      of the client being idle or some other reason causing the server
    1659     *      to send FTP reply code 421.  This exception may be caught either
    1660     *      as an IOException or independently as itself.
    1661     * @throws IOException  If an I/O error occurs while either sending the
    1662     *      command or receiving the server reply.
    1663     * @since 3.0
    1664     */
    1665    public int mlst(final String path) throws IOException
    1666    {
    1667        return sendCommand(FTPCmd.MLST, path);
    1668    }
    1669
    1670    /***
    1671     * A convenience method to send the FTP NLST command to the server,
    1672     * receive the reply, and return the reply code.  Remember, it is up
    1673     * to you to manage the data connection.  If you don't need this low
    1674     * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
    1675     * , which will handle all low level details for you.
    1676     *
    1677     * @return The reply code received from the server.
    1678     * @throws FTPConnectionClosedException
    1679     *      If the FTP server prematurely closes the connection as a result
    1680     *      of the client being idle or some other reason causing the server
    1681     *      to send FTP reply code 421.  This exception may be caught either
    1682     *      as an IOException or independently as itself.
    1683     * @throws IOException  If an I/O error occurs while either sending the
    1684     *      command or receiving the server reply.
    1685     ***/
    1686    public int nlst() throws IOException
    1687    {
    1688        return sendCommand(FTPCmd.NLST);
    1689    }
    1690
    1691    /***
    1692     * A convenience method to send the FTP NLST command to the server,
    1693     * receive the reply, and return the reply code.  Remember, it is up
    1694     * to you to manage the data connection.  If you don't need this low
    1695     * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
    1696     * , which will handle all low level details for you.
    1697     *
    1698     * @param pathname  The pathname to list,
    1699     * may be {@code null} in which case the command is sent with no parameters
    1700     * @return The reply code received from the server.
    1701     * @throws FTPConnectionClosedException
    1702     *      If the FTP server prematurely closes the connection as a result
    1703     *      of the client being idle or some other reason causing the server
    1704     *      to send FTP reply code 421.  This exception may be caught either
    1705     *      as an IOException or independently as itself.
    1706     * @throws IOException  If an I/O error occurs while either sending the
    1707     *      command or receiving the server reply.
    1708     ***/
    1709    public int nlst(final String pathname) throws IOException
    1710    {
    1711        return sendCommand(FTPCmd.NLST, pathname);
    1712    }
    1713
    1714    /***
    1715     * A convenience method to send the FTP SITE command to the server,
    1716     * receive the reply, and return the reply code.
    1717     *
    1718     * @param parameters  The site parameters to send.
    1719     * @return The reply code received from the server.
    1720     * @throws FTPConnectionClosedException
    1721     *      If the FTP server prematurely closes the connection as a result
    1722     *      of the client being idle or some other reason causing the server
    1723     *      to send FTP reply code 421.  This exception may be caught either
    1724     *      as an IOException or independently as itself.
    1725     * @throws IOException  If an I/O error occurs while either sending the
    1726     *      command or receiving the server reply.
    1727     ***/
    1728    public int site(final String parameters) throws IOException
    1729    {
    1730        return sendCommand(FTPCmd.SITE, parameters);
    1731    }
    1732
    1733    /***
    1734     * A convenience method to send the FTP SIZE command to the server,
    1735     * receive the reply, and return the reply code.
    1736     *
    1737     * @param parameters  The site parameters to send.
    1738     * @return The reply code received from the server.
    1739     * @throws FTPConnectionClosedException
    1740     *      If the FTP server prematurely closes the connection as a result
    1741     *      of the client being idle or some other reason causing the server
    1742     *      to send FTP reply code 421.  This exception may be caught either
    1743     *      as an IOException or independently as itself.
    1744     * @throws IOException  If an I/O error occurs while either sending the
    1745     *      command or receiving the server reply.
    1746     * @since 3.7
    1747     ***/
    1748    public int size(final String parameters) throws IOException
    1749    {
    1750        return sendCommand(FTPCmd.SIZE, parameters);
    1751    }
    1752
    1753    /***
    1754     * A convenience method to send the FTP SYST command to the server,
    1755     * receive the reply, and return the reply code.
    1756     *
    1757     * @return The reply code received from the server.
    1758     * @throws FTPConnectionClosedException
    1759     *      If the FTP server prematurely closes the connection as a result
    1760     *      of the client being idle or some other reason causing the server
    1761     *      to send FTP reply code 421.  This exception may be caught either
    1762     *      as an IOException or independently as itself.
    1763     * @throws IOException  If an I/O error occurs while either sending the
    1764     *      command or receiving the server reply.
    1765     ***/
    1766    public int syst() throws IOException
    1767    {
    1768        return sendCommand(FTPCmd.SYST);
    1769    }
    1770
    1771    /***
    1772     * A convenience method to send the FTP STAT command to the server,
    1773     * receive the reply, and return the reply code.
    1774     *
    1775     * @return The reply code received from the server.
    1776     * @throws FTPConnectionClosedException
    1777     *      If the FTP server prematurely closes the connection as a result
    1778     *      of the client being idle or some other reason causing the server
    1779     *      to send FTP reply code 421.  This exception may be caught either
    1780     *      as an IOException or independently as itself.
    1781     * @throws IOException  If an I/O error occurs while either sending the
    1782     *      command or receiving the server reply.
    1783     ***/
    1784    public int stat() throws IOException
    1785    {
    1786        return sendCommand(FTPCmd.STAT);
    1787    }
    1788
    1789    /***
    1790     * A convenience method to send the FTP STAT command to the server,
    1791     * receive the reply, and return the reply code.
    1792     *
    1793     * @param pathname  A pathname to list.
    1794     * @return The reply code received from the server.
    1795     * @throws FTPConnectionClosedException
    1796     *      If the FTP server prematurely closes the connection as a result
    1797     *      of the client being idle or some other reason causing the server
    1798     *      to send FTP reply code 421.  This exception may be caught either
    1799     *      as an IOException or independently as itself.
    1800     * @throws IOException  If an I/O error occurs while either sending the
    1801     *      command or receiving the server reply.
    1802     ***/
    1803    public int stat(final String pathname) throws IOException
    1804    {
    1805        return sendCommand(FTPCmd.STAT, pathname);
    1806    }
    1807
    1808    /***
    1809     * A convenience method to send the FTP HELP command to the server,
    1810     * receive the reply, and return the reply code.
    1811     *
    1812     * @return The reply code received from the server.
    1813     * @throws FTPConnectionClosedException
    1814     *      If the FTP server prematurely closes the connection as a result
    1815     *      of the client being idle or some other reason causing the server
    1816     *      to send FTP reply code 421.  This exception may be caught either
    1817     *      as an IOException or independently as itself.
    1818     * @throws IOException  If an I/O error occurs while either sending the
    1819     *      command or receiving the server reply.
    1820     ***/
    1821    public int help() throws IOException
    1822    {
    1823        return sendCommand(FTPCmd.HELP);
    1824    }
    1825
    1826    /***
    1827     * A convenience method to send the FTP HELP command to the server,
    1828     * receive the reply, and return the reply code.
    1829     *
    1830     * @param command  The command name on which to request help.
    1831     * @return The reply code received from the server.
    1832     * @throws FTPConnectionClosedException
    1833     *      If the FTP server prematurely closes the connection as a result
    1834     *      of the client being idle or some other reason causing the server
    1835     *      to send FTP reply code 421.  This exception may be caught either
    1836     *      as an IOException or independently as itself.
    1837     * @throws IOException  If an I/O error occurs while either sending the
    1838     *      command or receiving the server reply.
    1839     ***/
    1840    public int help(final String command) throws IOException
    1841    {
    1842        return sendCommand(FTPCmd.HELP, command);
    1843    }
    1844
    1845    /***
    1846     * A convenience method to send the FTP NOOP command to the server,
    1847     * receive the reply, and return the reply code.
    1848     *
    1849     * @return The reply code received from the server.
    1850     * @throws FTPConnectionClosedException
    1851     *      If the FTP server prematurely closes the connection as a result
    1852     *      of the client being idle or some other reason causing the server
    1853     *      to send FTP reply code 421.  This exception may be caught either
    1854     *      as an IOException or independently as itself.
    1855     * @throws IOException  If an I/O error occurs while either sending the
    1856     *      command or receiving the server reply.
    1857     ***/
    1858    public int noop() throws IOException
    1859    {
    1860        return sendCommand(FTPCmd.NOOP);
    1861    }
    1862
    1863    /**
    1864     * Return whether strict multiline parsing is enabled, as per RFC 959, section 4.2.
    1865     * @return True if strict, false if lenient
    1866     * @since 2.0
    1867     */
    1868    public boolean isStrictMultilineParsing() {
    1869        return strictMultilineParsing;
    1870    }
    1871
    1872    /**
    1873     * Set strict multiline parsing.
    1874     * @param strictMultilineParsing the setting
    1875     * @since 2.0
    1876     */
    1877    public void setStrictMultilineParsing(final boolean strictMultilineParsing) {
    1878        this.strictMultilineParsing = strictMultilineParsing;
    1879    }
    1880
    1881    /**
    1882     * Return whether strict non-multiline parsing is enabled, as per RFC 959, section 4.2.
    1883     * <p>
    1884     * The default is true, which requires the 3 digit code be followed by space and some text.
    1885     * <br>
    1886     * If false, only the 3 digit code is required (as was the case for versions up to 3.5)
    1887     * <br>
    1888     * @return True if strict (default), false if additional checks are not made
    1889     * @since 3.6
    1890     */
    1891    public boolean isStrictReplyParsing() {
    1892        return strictReplyParsing;
    1893    }
    1894
    1895    /**
    1896     * Set strict non-multiline parsing.
    1897     * <p>
    1898     * If true, it requires the 3 digit code be followed by space and some text.
    1899     * <br>
    1900     * If false, only the 3 digit code is required (as was the case for versions up to 3.5)
    1901     * <p>
    1902     * <b>This should not be required by a well-behaved FTP server</b>
    1903     * <br>
    1904     * @param strictReplyParsing the setting
    1905     * @since 3.6
    1906     */
    1907    public void setStrictReplyParsing(final boolean strictReplyParsing) {
    1908        this.strictReplyParsing = strictReplyParsing;
    1909    }
    1910
    1911    /**
    1912     * Provide command support to super-class
    1913     */
    1914    @Override
    1915    protected ProtocolCommandSupport getCommandSupport() {
    1916        return _commandSupport_;
    1917    }
    1918}
    1919
    1920/* Emacs configuration
    1921 * Local variables:        **
    1922 * mode:             java  **
    1923 * c-basic-offset:   4     **
    1924 * indent-tabs-mode: nil   **
    1925 * End:                    **
    1926 */