View Javadoc

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