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