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     */