View Javadoc

1   /*
2    * Copyright 2001-2005 The Apache Software Foundation
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    *     http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  package org.apache.commons.net.ftp;
17  import java.io.BufferedReader;
18  import java.io.BufferedWriter;
19  import java.io.IOException;
20  import java.io.InputStreamReader;
21  import java.io.OutputStreamWriter;
22  import java.lang.reflect.InvocationTargetException;
23  import java.lang.reflect.Method;
24  import java.net.InetAddress;
25  import java.net.Socket;
26  import java.net.SocketException;
27  import java.util.Enumeration;
28  import java.util.Vector;
29  
30  import org.apache.commons.net.MalformedServerReplyException;
31  import org.apache.commons.net.ProtocolCommandListener;
32  import org.apache.commons.net.ProtocolCommandSupport;
33  import org.apache.commons.net.SocketClient;
34  import org.apache.commons.net.telnet.TelnetClient;
35  
36  /***
37   * FTP provides the basic the functionality necessary to implement your
38   * own FTP client.  It extends org.apache.commons.net.TelnetClient
39   * simply because it saves the writing of extra code to handle the FTP
40   * control connection which always remains open during an FTP session and
41   * uses the Telnet protocol.  Aggregation would require writing new
42   * wrapper methods and wouldn't leverage the functionality already
43   * present in org.apache.commons.net.SocketClient.
44   * <p>
45   * To derive the full benefits of the FTP class requires some knowledge
46   * of the FTP protocol defined in RFC 959.  However, there is no reason
47   * why you should have to use the FTP class.  The
48   * {@link org.apache.commons.net.ftp.FTPClient} class,
49   * derived from FTP,
50   * implements all the functionality required of an FTP client.  The
51   * FTP class is made public to provide access to various FTP constants
52   * and to make it easier for adventurous programmers (or those with
53   * special needs) to interact with the FTP protocol and implement their
54   * own clients.  A set of methods with names corresponding to the FTP
55   * command names are provided to facilitate this interaction.
56   * <p>
57   * You should keep in mind that the FTP server may choose to prematurely
58   * close a connection if the client has been idle for longer than a
59   * given time period (usually 900 seconds).  The FTP class will detect a
60   * premature FTP server connection closing when it receives a
61   * {@link org.apache.commons.net.ftp.FTPReply#SERVICE_NOT_AVAILABLE FTPReply.SERVICE_NOT_AVAILABLE }
62   *  response to a command.
63   * When that occurs, the FTP class method encountering that reply will throw
64   * an {@link org.apache.commons.net.ftp.FTPConnectionClosedException}
65   * .  <code>FTPConectionClosedException</code>
66   * is a subclass of <code> IOException </code> and therefore need not be
67   * caught separately, but if you are going to catch it separately, its
68   * catch block must appear before the more general <code> IOException </code>
69   * catch block.  When you encounter an
70   * {@link org.apache.commons.net.ftp.FTPConnectionClosedException}
71   * , you must disconnect the connection with
72   * {@link #disconnect  disconnect() } to properly clean up the
73   * system resources used by FTP.  Before disconnecting, you may check the
74   * last reply code and text with
75   * {@link #getReplyCode  getReplyCode },
76   * {@link #getReplyString  getReplyString },
77   * and {@link #getReplyStrings  getReplyStrings}.
78   * You may avoid server disconnections while the client is idle by
79   * periodicaly sending NOOP commands to the server.
80   * <p>
81   * Rather than list it separately for each method, we mention here that
82   * every method communicating with the server and throwing an IOException
83   * can also throw a
84   * {@link org.apache.commons.net.MalformedServerReplyException}
85   * , which is a subclass
86   * of IOException.  A MalformedServerReplyException will be thrown when
87   * the reply received from the server deviates enough from the protocol
88   * specification that it cannot be interpreted in a useful manner despite
89   * attempts to be as lenient as possible.
90   * <p>
91   * <p>
92   * @author Daniel F. Savarese
93   * @see FTPClient
94   * @see FTPConnectionClosedException
95   * @see org.apache.commons.net.MalformedServerReplyException
96   ***/
97  
98  public class FTP extends TelnetClient
99  {
100     /*** The default FTP data port (20). ***/
101     public static final int DEFAULT_DATA_PORT = 20;
102     /*** The default FTP control port (21). ***/
103     public static final int DEFAULT_PORT = 21;
104 
105     /***
106      * A constant used to indicate the file(s) being transfered should
107      * be treated as ASCII.  This is the default file type.  All constants
108      * ending in <code>FILE_TYPE</code> are used to indicate file types.
109      ***/
110     public static final int ASCII_FILE_TYPE = 0;
111 
112     /***
113      * A constant used to indicate the file(s) being transfered should
114      * be treated as EBCDIC.  Note however that there are several different
115      * EBCDIC formats.  All constants ending in <code>FILE_TYPE</code>
116      * are used to indicate file types.
117      ***/
118     public static final int EBCDIC_FILE_TYPE = 1;
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 IMAGE_FILE_TYPE = 2;
127 
128     /***
129      * A constant used to indicate the file(s) being transfered should
130      * be treated as a binary image, i.e., no translations should be
131      * performed.  All constants ending in <code>FILE_TYPE</code> are used to
132      * indicate file types.
133      ***/
134     public static final int BINARY_FILE_TYPE = 2;
135 
136     /***
137      * A constant used to indicate the file(s) being transfered should
138      * be treated as a local type.  All constants ending in
139      * <code>FILE_TYPE</code> are used to indicate file types.
140      ***/
141     public static final int LOCAL_FILE_TYPE = 3;
142 
143     /***
144      * A constant used for text files to indicate a non-print text format.
145      * This is the default format.
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 NON_PRINT_TEXT_FORMAT = 4;
150 
151     /***
152      * A constant used to indicate a text file contains format 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 TELNET_TEXT_FORMAT = 5;
158 
159     /***
160      * A constant used to indicate a text file contains ASA vertical format
161      * control characters.
162      * All constants ending in <code>TEXT_FORMAT</code> are used to indicate
163      * text formatting for text transfers (both ASCII and EBCDIC).
164      ***/
165     public static final int CARRIAGE_CONTROL_TEXT_FORMAT = 6;
166 
167     /***
168      * A constant used to indicate a file is to be treated as a continuous
169      * sequence of bytes.  This is the default structure.  All constants ending
170      * in <code>_STRUCTURE</code> are used to indicate file structure for
171      * file transfers.
172      ***/
173     public static final int FILE_STRUCTURE = 7;
174 
175     /***
176      * A constant used to indicate a file is to be treated as a sequence
177      * of records.  All constants ending in <code>_STRUCTURE</code>
178      * are used to indicate file structure for file transfers.
179      ***/
180     public static final int RECORD_STRUCTURE = 8;
181 
182     /***
183      * A constant used to indicate a file is to be treated as a set of
184      * independent indexed pages.  All constants ending in
185      * <code>_STRUCTURE</code> are used to indicate file structure for file
186      * transfers.
187      ***/
188     public static final int PAGE_STRUCTURE = 9;
189 
190     /***
191      * A constant used to indicate a file is to be transfered as a stream
192      * of bytes.  This is the default transfer mode.  All constants ending
193      * in <code>TRANSFER_MODE</code> are used to indicate file transfer
194      * modes.
195      ***/
196     public static final int STREAM_TRANSFER_MODE = 10;
197 
198     /***
199      * A constant used to indicate a file is to be transfered as a series
200      * of blocks.  All constants ending in <code>TRANSFER_MODE</code> are used
201      * to indicate file transfer modes.
202      ***/
203     public static final int BLOCK_TRANSFER_MODE = 11;
204 
205     /***
206      * A constant used to indicate a file is to be transfered as FTP
207      * compressed data.  All constants ending in <code>TRANSFER_MODE</code>
208      * are used to indicate file transfer modes.
209      ***/
210     public static final int COMPRESSED_TRANSFER_MODE = 12;
211 
212     // We have to ensure that the protocol communication is in ASCII
213     // but we use ISO-8859-1 just in case 8-bit characters cross
214     // the wire.
215     /**
216      * The default character encoding used for communicating over an
217      * FTP control connection.  The default encoding is an
218      * ASCII-compatible encoding.  Some FTP servers expect other
219      * encodings.  You can change the encoding used by an FTP instance
220      * with {@link #setControlEncoding setControlEncoding}.
221      */
222     public static final String DEFAULT_CONTROL_ENCODING = "ISO-8859-1";
223     private static final String __modes = "ABILNTCFRPSBC";
224 
225     private StringBuffer __commandBuffer;
226 
227     BufferedReader _controlInput;
228     BufferedWriter _controlOutput;
229     int _replyCode;
230     Vector _replyLines;
231     boolean _newReplyString;
232     String _replyString;
233     String _controlEncoding;
234 
235     /***
236      * A ProtocolCommandSupport object used to manage the registering of
237      * ProtocolCommandListeners and te firing of ProtocolCommandEvents.
238      ***/
239     protected ProtocolCommandSupport _commandSupport_;
240 
241     /***
242      * The default FTP constructor.  Sets the default port to
243      * <code>DEFAULT_PORT</code> and initializes internal data structures
244      * for saving FTP reply information.
245      ***/
246     public FTP()
247     {
248         setDefaultPort(DEFAULT_PORT);
249         __commandBuffer = new StringBuffer();
250         _replyLines = new Vector();
251         _newReplyString = false;
252         _replyString = null;
253         _commandSupport_ = new ProtocolCommandSupport(this);
254         _controlEncoding = DEFAULT_CONTROL_ENCODING;
255     }
256 
257     private void __getReply() throws IOException
258     {
259         int length;
260 
261         _newReplyString = true;
262         _replyLines.setSize(0);
263 
264         String line = _controlInput.readLine();
265 
266         if (line == null)
267             throw new FTPConnectionClosedException(
268                 "Connection closed without indication.");
269 
270         // In case we run into an anomaly we don't want fatal index exceptions
271         // to be thrown.
272         length = line.length();
273         if (length < 3)
274             throw new MalformedServerReplyException(
275                 "Truncated server reply: " + line);
276 
277         try
278         {
279             String code = line.substring(0, 3);
280             _replyCode = Integer.parseInt(code);
281         }
282         catch (NumberFormatException e)
283         {
284             throw new MalformedServerReplyException(
285                 "Could not parse response code.\nServer Reply: " + line);
286         }
287 
288         _replyLines.addElement(line);
289 
290         // Get extra lines if message continues.
291         if (length > 3 && line.charAt(3) == '-')
292         {
293             do
294             {
295                 line = _controlInput.readLine();
296 
297                 if (line == null)
298                     throw new FTPConnectionClosedException(
299                         "Connection closed without indication.");
300 
301                 _replyLines.addElement(line);
302 
303                 // The length() check handles problems that could arise from readLine()
304                 // returning too soon after encountering a naked CR or some other
305                 // anomaly.
306             }
307             while (!(line.length() >= 4 && line.charAt(3) != '-' &&
308                      Character.isDigit(line.charAt(0))));
309             // This is too strong a condition because of non-conforming ftp
310             // servers like ftp.funet.fi which sent 226 as the last line of a
311             // 426 multi-line reply in response to ls /.  We relax the condition to
312             // test that the line starts with a digit rather than starting with
313             // the code.
314             // line.startsWith(code)));
315         }
316 
317         if (_commandSupport_.getListenerCount() > 0)
318             _commandSupport_.fireReplyReceived(_replyCode, getReplyString());
319 
320         if (_replyCode == FTPReply.SERVICE_NOT_AVAILABLE)
321             throw new FTPConnectionClosedException(
322                 "FTP response 421 received.  Server closed connection.");
323     }
324 
325     // initiates control connections and gets initial reply
326     protected void _connectAction_() throws IOException
327     {
328         super._connectAction_();
329         _controlInput =
330             new BufferedReader(new InputStreamReader(getInputStream(),
331                                                      getControlEncoding()));
332         _controlOutput =
333             new BufferedWriter(new OutputStreamWriter(getOutputStream(),
334                                                       getControlEncoding()));
335         __getReply();
336         // If we received code 120, we have to fetch completion reply.
337         if (FTPReply.isPositivePreliminary(_replyCode))
338             __getReply();
339     }
340 
341 
342     /**
343      * Sets the character encoding used by the FTP control connection.
344      * Some FTP servers require that commands be issued in a non-ASCII
345      * encoding like UTF-8 so that filenames with multi-byte character
346      * representations (e.g, Big 8) can be specified.
347      *
348      * @param encoding The new character encoding for the control connection.
349      */
350     public void setControlEncoding(String encoding) {
351         _controlEncoding = encoding;
352     }
353 
354 
355     /**
356      * @return The character encoding used to communicate over the
357      * control connection.
358      */
359     public String getControlEncoding() {
360         return _controlEncoding;
361     }
362 
363 
364     /***
365      * Adds a ProtocolCommandListener.  Delegates this task to
366      * {@link #_commandSupport_  _commandSupport_ }.
367      * <p>
368      * @param listener  The ProtocolCommandListener to add.
369      ***/
370     public void addProtocolCommandListener(ProtocolCommandListener listener)
371     {
372         _commandSupport_.addProtocolCommandListener(listener);
373     }
374 
375     /***
376      * Removes a ProtocolCommandListener.  Delegates this task to
377      * {@link #_commandSupport_  _commandSupport_ }.
378      * <p>
379      * @param listener  The ProtocolCommandListener to remove.
380      ***/
381     public void removeProtocolCommandListener(ProtocolCommandListener listener)
382     {
383         _commandSupport_.removeProtocolCommandListener(listener);
384     }
385 
386 
387     /***
388      * Closes the control connection to the FTP server and sets to null
389      * some internal data so that the memory may be reclaimed by the
390      * garbage collector.  The reply text and code information from the
391      * last command is voided so that the memory it used may be reclaimed.
392      * <p>
393      * @exception IOException If an error occurs while disconnecting.
394      ***/
395     public void disconnect() throws IOException
396     {
397         super.disconnect();
398         _controlInput = null;
399         _controlOutput = null;
400         _replyLines.setSize(0);
401         _newReplyString = false;
402         _replyString = null;
403     }
404 
405 
406     /***
407      * Sends an FTP command to the server, waits for a reply and returns the
408      * numerical response code.  After invocation, for more detailed
409      * information, the actual reply text can be accessed by calling
410      * {@link #getReplyString  getReplyString } or
411      * {@link #getReplyStrings  getReplyStrings }.
412      * <p>
413      * @param command  The text representation of the  FTP command to send.
414      * @param args The arguments to the FTP command.  If this parameter is
415      *             set to null, then the command is sent with no argument.
416      * @return The integer value of the FTP reply code returned by the server
417      *         in response to the command.
418      * @exception FTPConnectionClosedException
419      *      If the FTP server prematurely closes the connection as a result
420      *      of the client being idle or some other reason causing the server
421      *      to send FTP reply code 421.  This exception may be caught either
422      *      as an IOException or independently as itself.
423      * @exception IOException  If an I/O error occurs while either sending the
424      *      command or receiving the server reply.
425      ***/
426     public int sendCommand(String command, String args) throws IOException
427     {
428         String message;
429 
430         __commandBuffer.setLength(0);
431         __commandBuffer.append(command);
432 
433         if (args != null)
434         {
435             __commandBuffer.append(' ');
436             __commandBuffer.append(args);
437         }
438         __commandBuffer.append(SocketClient.NETASCII_EOL);
439 
440         try{
441 	    _controlOutput.write(message = __commandBuffer.toString());
442         _controlOutput.flush();
443         }
444         catch (SocketException e)
445         {
446             if (!isConnected() || !socketIsConnected(_socket_))
447             {
448                 throw new FTPConnectionClosedException("Connection unexpectedly closed.");
449             }
450             else
451             {
452                 throw e;
453             }
454         }
455 	
456 
457         if (_commandSupport_.getListenerCount() > 0)
458             _commandSupport_.fireCommandSent(command, message);
459 
460         __getReply();
461         return _replyCode;
462     }
463 
464     /**
465      * Checks if the socket is connected using reflection to be backward compatible.
466      * The return value of this method is only meaningful in an java 1.4 environment.
467      *
468      * @param socket
469      * @return true if connected or pre java 1.4
470      */
471     private boolean socketIsConnected(Socket socket)
472     {
473         if (socket == null)
474         {
475             return false;
476         }
477 
478         try
479         {
480             Method isConnected = socket.getClass().getMethod("isConnected", null);
481             return ((Boolean) isConnected.invoke(socket, null)).booleanValue();
482         }
483         catch (NoSuchMethodException e)
484         {
485             return true;
486         }
487         catch (IllegalAccessException e)
488         {
489             return true;
490         }
491         catch (InvocationTargetException e)
492         {
493             return true;
494         }
495     }
496 
497     /***
498      * Sends an FTP command to the server, waits for a reply and returns the
499      * numerical response code.  After invocation, for more detailed
500      * information, the actual reply text can be accessed by calling
501      * {@link #getReplyString  getReplyString } or
502      * {@link #getReplyStrings  getReplyStrings }.
503      * <p>
504      * @param command  The FTPCommand constant corresponding to the FTP command
505      *                 to send.
506      * @param args The arguments to the FTP command.  If this parameter is
507      *             set to null, then the command is sent with no argument.
508      * @return The integer value of the FTP reply code returned by the server
509      *         in response to the command.
510      * @exception FTPConnectionClosedException
511      *      If the FTP server prematurely closes the connection as a result
512      *      of the client being idle or some other reason causing the server
513      *      to send FTP reply code 421.  This exception may be caught either
514      *      as an IOException or independently as itself.
515      * @exception IOException  If an I/O error occurs while either sending the
516      *      command or receiving the server reply.
517      ***/
518     public int sendCommand(int command, String args) throws IOException
519     {
520         return sendCommand(FTPCommand._commands[command], args);
521     }
522 
523 
524     /***
525      * Sends an FTP command with no arguments to the server, waits for a
526      * reply and returns the numerical response code.  After invocation, for
527      * more detailed information, the actual reply text can be accessed by
528      * calling {@link #getReplyString  getReplyString } or
529      * {@link #getReplyStrings  getReplyStrings }.
530      * <p>
531      * @param command  The text representation of the  FTP command to send.
532      * @return The integer value of the FTP reply code returned by the server
533      *         in response to the command.
534      * @exception FTPConnectionClosedException
535      *      If the FTP server prematurely closes the connection as a result
536      *      of the client being idle or some other reason causing the server
537      *      to send FTP reply code 421.  This exception may be caught either
538      *      as an IOException or independently as itself.
539      * @exception IOException  If an I/O error occurs while either sending the
540      *      command or receiving the server reply.
541      ***/
542     public int sendCommand(String command) throws IOException
543     {
544         return sendCommand(command, null);
545     }
546 
547 
548     /***
549      * Sends an FTP command with no arguments to the server, waits for a
550      * reply and returns the numerical response code.  After invocation, for
551      * more detailed information, the actual reply text can be accessed by
552      * calling {@link #getReplyString  getReplyString } or
553      * {@link #getReplyStrings  getReplyStrings }.
554      * <p>
555      * @param command  The FTPCommand constant corresponding to the FTP command
556      *                 to send.
557      * @return The integer value of the FTP reply code returned by the server
558      *         in response to the command.
559      * @exception FTPConnectionClosedException
560      *      If the FTP server prematurely closes the connection as a result
561      *      of the client being idle or some other reason causing the server
562      *      to send FTP reply code 421.  This exception may be caught either
563      *      as an IOException or independently as itself.
564      * @exception IOException  If an I/O error occurs while either sending the
565      *      command or receiving the server reply.
566      ***/
567     public int sendCommand(int command) throws IOException
568     {
569         return sendCommand(command, null);
570     }
571 
572 
573     /***
574      * Returns the integer value of the reply code of the last FTP reply.
575      * You will usually only use this method after you connect to the
576      * FTP server to check that the connection was successful since
577      * <code> connect </code> is of type void.
578      * <p>
579      * @return The integer value of the reply code of the last FTP reply.
580      ***/
581     public int getReplyCode()
582     {
583         return _replyCode;
584     }
585 
586     /***
587      * Fetches a reply from the FTP server and returns the integer reply
588      * code.  After calling this method, the actual reply text can be accessed
589      * from either  calling {@link #getReplyString  getReplyString } or
590      * {@link #getReplyStrings  getReplyStrings }.  Only use this
591      * method if you are implementing your own FTP client or if you need to
592      * fetch a secondary response from the FTP server.
593      * <p>
594      * @return The integer value of the reply code of the fetched FTP reply.
595      * @exception FTPConnectionClosedException
596      *      If the FTP server prematurely closes the connection as a result
597      *      of the client being idle or some other reason causing the server
598      *      to send FTP reply code 421.  This exception may be caught either
599      *      as an IOException or independently as itself.
600      * @exception IOException  If an I/O error occurs while receiving the
601      *                         server reply.
602      ***/
603     public int getReply() throws IOException
604     {
605         __getReply();
606         return _replyCode;
607     }
608 
609 
610     /***
611      * Returns the lines of text from the last FTP server response as an array
612      * of strings, one entry per line.  The end of line markers of each are
613      * stripped from each line.
614      * <p>
615      * @return The lines of text from the last FTP response as an array.
616      ***/
617     public String[] getReplyStrings()
618     {
619         String[] lines;
620         lines = new String[_replyLines.size()];
621         _replyLines.copyInto(lines);
622         return lines;
623     }
624 
625     /***
626      * Returns the entire text of the last FTP server response exactly
627      * as it was received, including all end of line markers in NETASCII
628      * format.
629      * <p>
630      * @return The entire text from the last FTP response as a String.
631      ***/
632     public String getReplyString()
633     {
634         Enumeration en;
635         StringBuffer buffer;
636 
637         if (!_newReplyString)
638             return _replyString;
639 
640         buffer = new StringBuffer(256);
641         en = _replyLines.elements();
642         while (en.hasMoreElements())
643         {
644             buffer.append((String)en.nextElement());
645             buffer.append(SocketClient.NETASCII_EOL);
646         }
647 
648         _newReplyString = false;
649 
650         return (_replyString = buffer.toString());
651     }
652 
653 
654     /***
655      * A convenience method to send the FTP USER command to the server,
656      * receive the reply, and return the reply code.
657      * <p>
658      * @param username  The username to login under.
659      * @return The reply code received from the server.
660      * @exception FTPConnectionClosedException
661      *      If the FTP server prematurely closes the connection as a result
662      *      of the client being idle or some other reason causing the server
663      *      to send FTP reply code 421.  This exception may be caught either
664      *      as an IOException or independently as itself.
665      * @exception IOException  If an I/O error occurs while either sending the
666      *      command or receiving the server reply.
667      ***/
668     public int user(String username) throws IOException
669     {
670         return sendCommand(FTPCommand.USER, username);
671     }
672 
673     /**
674      * A convenience method to send the FTP PASS command to the server,
675      * receive the reply, and return the reply code.
676      * @param password The plain text password of the username being logged into.
677      * @return The reply code received from the server.
678      * @exception FTPConnectionClosedException
679      *      If the FTP server prematurely closes the connection as a result
680      *      of the client being idle or some other reason causing the server
681      *      to send FTP reply code 421.  This exception may be caught either
682      *      as an IOException or independently as itself.
683      * @exception IOException  If an I/O error occurs while either sending the
684      *      command or receiving the server reply.
685      */
686     public int pass(String password) throws IOException
687     {
688         return sendCommand(FTPCommand.PASS, password);
689     }
690 
691     /***
692      * A convenience method to send the FTP ACCT command to the server,
693      * receive the reply, and return the reply code.
694      * <p>
695      * @param account  The account name to access.
696      * @return The reply code received from the server.
697      * @exception FTPConnectionClosedException
698      *      If the FTP server prematurely closes the connection as a result
699      *      of the client being idle or some other reason causing the server
700      *      to send FTP reply code 421.  This exception may be caught either
701      *      as an IOException or independently as itself.
702      * @exception IOException  If an I/O error occurs while either sending the
703      *      command or receiving the server reply.
704      ***/
705     public int acct(String account) throws IOException
706     {
707         return sendCommand(FTPCommand.ACCT, account);
708     }
709 
710 
711     /***
712      * A convenience method to send the FTP ABOR command to the server,
713      * receive the reply, and return the reply code.
714      * <p>
715      * @return The reply code received from the server.
716      * @exception FTPConnectionClosedException
717      *      If the FTP server prematurely closes the connection as a result
718      *      of the client being idle or some other reason causing the server
719      *      to send FTP reply code 421.  This exception may be caught either
720      *      as an IOException or independently as itself.
721      * @exception IOException  If an I/O error occurs while either sending the
722      *      command or receiving the server reply.
723      ***/
724     public int abor() throws IOException
725     {
726         return sendCommand(FTPCommand.ABOR);
727     }
728 
729     /***
730      * A convenience method to send the FTP CWD command to the server,
731      * receive the reply, and return the reply code.
732      * <p>
733      * @param directory The new working directory.
734      * @return The reply code received from the server.
735      * @exception FTPConnectionClosedException
736      *      If the FTP server prematurely closes the connection as a result
737      *      of the client being idle or some other reason causing the server
738      *      to send FTP reply code 421.  This exception may be caught either
739      *      as an IOException or independently as itself.
740      * @exception IOException  If an I/O error occurs while either sending the
741      *      command or receiving the server reply.
742      ***/
743     public int cwd(String directory) throws IOException
744     {
745         return sendCommand(FTPCommand.CWD, directory);
746     }
747 
748     /***
749      * A convenience method to send the FTP CDUP command to the server,
750      * receive the reply, and return the reply code.
751      * <p>
752      * @return The reply code received from the server.
753      * @exception FTPConnectionClosedException
754      *      If the FTP server prematurely closes the connection as a result
755      *      of the client being idle or some other reason causing the server
756      *      to send FTP reply code 421.  This exception may be caught either
757      *      as an IOException or independently as itself.
758      * @exception IOException  If an I/O error occurs while either sending the
759      *      command or receiving the server reply.
760      ***/
761     public int cdup() throws IOException
762     {
763         return sendCommand(FTPCommand.CDUP);
764     }
765 
766     /***
767      * A convenience method to send the FTP QUIT command to the server,
768      * receive the reply, and return the reply code.
769      * <p>
770      * @return The reply code received from the server.
771      * @exception FTPConnectionClosedException
772      *      If the FTP server prematurely closes the connection as a result
773      *      of the client being idle or some other reason causing the server
774      *      to send FTP reply code 421.  This exception may be caught either
775      *      as an IOException or independently as itself.
776      * @exception IOException  If an I/O error occurs while either sending the
777      *      command or receiving the server reply.
778      ***/
779     public int quit() throws IOException
780     {
781         return sendCommand(FTPCommand.QUIT);
782     }
783 
784     /***
785      * A convenience method to send the FTP REIN command to the server,
786      * receive the reply, and return the reply code.
787      * <p>
788      * @return The reply code received from the server.
789      * @exception FTPConnectionClosedException
790      *      If the FTP server prematurely closes the connection as a result
791      *      of the client being idle or some other reason causing the server
792      *      to send FTP reply code 421.  This exception may be caught either
793      *      as an IOException or independently as itself.
794      * @exception IOException  If an I/O error occurs while either sending the
795      *      command or receiving the server reply.
796      ***/
797     public int rein() throws IOException
798     {
799         return sendCommand(FTPCommand.REIN);
800     }
801 
802     /***
803      * A convenience method to send the FTP SMNT command to the server,
804      * receive the reply, and return the reply code.
805      * <p>
806      * @param dir  The directory name.
807      * @return The reply code received from the server.
808      * @exception FTPConnectionClosedException
809      *      If the FTP server prematurely closes the connection as a result
810      *      of the client being idle or some other reason causing the server
811      *      to send FTP reply code 421.  This exception may be caught either
812      *      as an IOException or independently as itself.
813      * @exception IOException  If an I/O error occurs while either sending the
814      *      command or receiving the server reply.
815      ***/
816     public int smnt(String dir) throws IOException
817     {
818         return sendCommand(FTPCommand.SMNT, dir);
819     }
820 
821     /***
822      * A convenience method to send the FTP PORT command to the server,
823      * receive the reply, and return the reply code.
824      * <p>
825      * @param host  The host owning the port.
826      * @param port  The new port.
827      * @return The reply code received from the server.
828      * @exception FTPConnectionClosedException
829      *      If the FTP server prematurely closes the connection as a result
830      *      of the client being idle or some other reason causing the server
831      *      to send FTP reply code 421.  This exception may be caught either
832      *      as an IOException or independently as itself.
833      * @exception IOException  If an I/O error occurs while either sending the
834      *      command or receiving the server reply.
835      ***/
836     public int port(InetAddress host, int port) throws IOException
837     {
838         int num;
839         StringBuffer info = new StringBuffer(24);
840 
841         info.append(host.getHostAddress().replace('.', ','));
842         num = port >>> 8;
843         info.append(',');
844         info.append(num);
845         info.append(',');
846         num = port & 0xff;
847         info.append(num);
848 
849         return sendCommand(FTPCommand.PORT, info.toString());
850     }
851 
852     /***
853      * A convenience method to send the FTP PASV command to the server,
854      * receive the reply, and return the reply code.  Remember, it's up
855      * to you to interpret the reply string containing the host/port
856      * information.
857      * <p>
858      * @return The reply code received from the server.
859      * @exception FTPConnectionClosedException
860      *      If the FTP server prematurely closes the connection as a result
861      *      of the client being idle or some other reason causing the server
862      *      to send FTP reply code 421.  This exception may be caught either
863      *      as an IOException or independently as itself.
864      * @exception IOException  If an I/O error occurs while either sending the
865      *      command or receiving the server reply.
866      ***/
867     public int pasv() throws IOException
868     {
869         return sendCommand(FTPCommand.PASV);
870     }
871 
872     /**
873      * A convenience method to send the FTP TYPE command for text files
874      * to the server, receive the reply, and return the reply code.
875      * @param fileType  The type of the file (one of the <code>FILE_TYPE</code>
876      *              constants).
877      * @param formatOrByteSize  The format of the file (one of the
878      *              <code>_FORMAT</code> constants.  In the case of
879      *              <code>LOCAL_FILE_TYPE</code>, the byte size.
880      * @return The reply code received from the server.
881      * @exception FTPConnectionClosedException
882      *      If the FTP server prematurely closes the connection as a result
883      *      of the client being idle or some other reason causing the server
884      *      to send FTP reply code 421.  This exception may be caught either
885      *      as an IOException or independently as itself.
886      * @exception IOException  If an I/O error occurs while either sending the
887      *      command or receiving the server reply.
888      */
889     public int type(int fileType, int formatOrByteSize) throws IOException
890     {
891         StringBuffer arg = new StringBuffer();
892 
893         arg.append(__modes.charAt(fileType));
894         arg.append(' ');
895         if (fileType == LOCAL_FILE_TYPE)
896             arg.append(formatOrByteSize);
897         else
898             arg.append(__modes.charAt(formatOrByteSize));
899 
900         return sendCommand(FTPCommand.TYPE, arg.toString());
901     }
902 
903 
904     /**
905      * A convenience method to send the FTP TYPE command to the server,
906      * receive the reply, and return the reply code.
907      * <p>
908      * @param fileType  The type of the file (one of the <code>FILE_TYPE</code>
909      *              constants).
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 type(int fileType) throws IOException
920     {
921         return sendCommand(FTPCommand.TYPE,
922                            __modes.substring(fileType, fileType + 1));
923     }
924 
925     /***
926      * A convenience method to send the FTP STRU command to the server,
927      * receive the reply, and return the reply code.
928      * <p>
929      * @param structure  The structure of the file (one of the
930      *         <code>_STRUCTURE</code> constants).
931      * @return The reply code received from the server.
932      * @exception FTPConnectionClosedException
933      *      If the FTP server prematurely closes the connection as a result
934      *      of the client being idle or some other reason causing the server
935      *      to send FTP reply code 421.  This exception may be caught either
936      *      as an IOException or independently as itself.
937      * @exception IOException  If an I/O error occurs while either sending the
938      *      command or receiving the server reply.
939      ***/
940     public int stru(int structure) throws IOException
941     {
942         return sendCommand(FTPCommand.STRU,
943                            __modes.substring(structure, structure + 1));
944     }
945 
946     /***
947      * A convenience method to send the FTP MODE command to the server,
948      * receive the reply, and return the reply code.
949      * <p>
950      * @param mode  The transfer mode to use (one of the
951      *         <code>TRANSFER_MODE</code> constants).
952      * @return The reply code received from the server.
953      * @exception FTPConnectionClosedException
954      *      If the FTP server prematurely closes the connection as a result
955      *      of the client being idle or some other reason causing the server
956      *      to send FTP reply code 421.  This exception may be caught either
957      *      as an IOException or independently as itself.
958      * @exception IOException  If an I/O error occurs while either sending the
959      *      command or receiving the server reply.
960      ***/
961     public int mode(int mode) throws IOException
962     {
963         return sendCommand(FTPCommand.MODE,
964                            __modes.substring(mode, mode + 1));
965     }
966 
967     /***
968      * A convenience method to send the FTP RETR command to the server,
969      * receive the reply, and return the reply code.  Remember, it is up
970      * to you to manage the data connection.  If you don't need this low
971      * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
972      * , which will handle all low level details for you.
973      * <p>
974      * @param pathname  The pathname of the file to retrieve.
975      * @return The reply code received from the server.
976      * @exception FTPConnectionClosedException
977      *      If the FTP server prematurely closes the connection as a result
978      *      of the client being idle or some other reason causing the server
979      *      to send FTP reply code 421.  This exception may be caught either
980      *      as an IOException or independently as itself.
981      * @exception IOException  If an I/O error occurs while either sending the
982      *      command or receiving the server reply.
983      ***/
984     public int retr(String pathname) throws IOException
985     {
986         return sendCommand(FTPCommand.RETR, pathname);
987     }
988 
989     /***
990      * A convenience method to send the FTP STOR command to the server,
991      * receive the reply, and return the reply code.  Remember, it is up
992      * to you to manage the data connection.  If you don't need this low
993      * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
994      * , which will handle all low level details for you.
995      * <p>
996      * @param pathname  The pathname to use for the file when stored at
997      *                  the remote end of the transfer.
998      * @return The reply code received from the server.
999      * @exception FTPConnectionClosedException
1000      *      If the FTP server prematurely closes the connection as a result
1001      *      of the client being idle or some other reason causing the server
1002      *      to send FTP reply code 421.  This exception may be caught either
1003      *      as an IOException or independently as itself.
1004      * @exception IOException  If an I/O error occurs while either sending the
1005      *      command or receiving the server reply.
1006      ***/
1007     public int stor(String pathname) throws IOException
1008     {
1009         return sendCommand(FTPCommand.STOR, pathname);
1010     }
1011 
1012     /***
1013      * A convenience method to send the FTP STOU command to the server,
1014      * receive the reply, and return the reply code.  Remember, it is up
1015      * to you to manage the data connection.  If you don't need this low
1016      * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1017      * , which will handle all low level details for you.
1018      * <p>
1019      * @return The reply code received from the server.
1020      * @exception FTPConnectionClosedException
1021      *      If the FTP server prematurely closes the connection as a result
1022      *      of the client being idle or some other reason causing the server
1023      *      to send FTP reply code 421.  This exception may be caught either
1024      *      as an IOException or independently as itself.
1025      * @exception IOException  If an I/O error occurs while either sending the
1026      *      command or receiving the server reply.
1027      ***/
1028     public int stou() throws IOException
1029     {
1030         return sendCommand(FTPCommand.STOU);
1031     }
1032 
1033     /***
1034      * A convenience method to send the FTP STOU command to the server,
1035      * receive the reply, and return the reply code.  Remember, it is up
1036      * to you to manage the data connection.  If you don't need this low
1037      * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1038      * , which will handle all low level details for you.
1039      * @param pathname  The base pathname to use for the file when stored at
1040      *                  the remote end of the transfer.  Some FTP servers
1041      *                  require this.
1042      * @return The reply code received from the server.
1043      * @exception FTPConnectionClosedException
1044      *      If the FTP server prematurely closes the connection as a result
1045      *      of the client being idle or some other reason causing the server
1046      *      to send FTP reply code 421.  This exception may be caught either
1047      *      as an IOException or independently as itself.
1048      * @exception IOException  If an I/O error occurs while either sending the
1049      *      command or receiving the server reply.
1050      */
1051     public int stou(String pathname) throws IOException
1052     {
1053         return sendCommand(FTPCommand.STOU, pathname);
1054     }
1055 
1056     /***
1057      * A convenience method to send the FTP APPE command to the server,
1058      * receive the reply, and return the reply code.  Remember, it is up
1059      * to you to manage the data connection.  If you don't need this low
1060      * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1061      * , which will handle all low level details for you.
1062      * <p>
1063      * @param pathname  The pathname to use for the file when stored at
1064      *                  the remote end of the transfer.
1065      * @return The reply code received from the server.
1066      * @exception FTPConnectionClosedException
1067      *      If the FTP server prematurely closes the connection as a result
1068      *      of the client being idle or some other reason causing the server
1069      *      to send FTP reply code 421.  This exception may be caught either
1070      *      as an IOException or independently as itself.
1071      * @exception IOException  If an I/O error occurs while either sending the
1072      *      command or receiving the server reply.
1073      ***/
1074     public int appe(String pathname) throws IOException
1075     {
1076         return sendCommand(FTPCommand.APPE, pathname);
1077     }
1078 
1079     /***
1080      * A convenience method to send the FTP ALLO command to the server,
1081      * receive the reply, and return the reply code.
1082      * <p>
1083      * @param bytes The number of bytes to allocate.
1084      * @return The reply code received from the server.
1085      * @exception FTPConnectionClosedException
1086      *      If the FTP server prematurely closes the connection as a result
1087      *      of the client being idle or some other reason causing the server
1088      *      to send FTP reply code 421.  This exception may be caught either
1089      *      as an IOException or independently as itself.
1090      * @exception IOException  If an I/O error occurs while either sending the
1091      *      command or receiving the server reply.
1092      ***/
1093     public int allo(int bytes) throws IOException
1094     {
1095         return sendCommand(FTPCommand.ALLO, Integer.toString(bytes));
1096     }
1097 
1098     /***
1099      * A convenience method to send the FTP ALLO command to the server,
1100      * receive the reply, and return the reply code.
1101      * <p>
1102      * @param bytes The number of bytes to allocate.
1103      * @param recordSize  The size of a record.
1104      * @return The reply code received from the server.
1105      * @exception FTPConnectionClosedException
1106      *      If the FTP server prematurely closes the connection as a result
1107      *      of the client being idle or some other reason causing the server
1108      *      to send FTP reply code 421.  This exception may be caught either
1109      *      as an IOException or independently as itself.
1110      * @exception IOException  If an I/O error occurs while either sending the
1111      *      command or receiving the server reply.
1112      ***/
1113     public int allo(int bytes, int recordSize) throws IOException
1114     {
1115         return sendCommand(FTPCommand.ALLO, Integer.toString(bytes) + " R " +
1116                            Integer.toString(recordSize));
1117     }
1118 
1119     /***
1120      * A convenience method to send the FTP REST command to the server,
1121      * receive the reply, and return the reply code.
1122      * <p>
1123      * @param marker The marker at which to restart a transfer.
1124      * @return The reply code received from the server.
1125      * @exception FTPConnectionClosedException
1126      *      If the FTP server prematurely closes the connection as a result
1127      *      of the client being idle or some other reason causing the server
1128      *      to send FTP reply code 421.  This exception may be caught either
1129      *      as an IOException or independently as itself.
1130      * @exception IOException  If an I/O error occurs while either sending the
1131      *      command or receiving the server reply.
1132      ***/
1133     public int rest(String marker) throws IOException
1134     {
1135         return sendCommand(FTPCommand.REST, marker);
1136     }
1137 
1138     /***
1139      * A convenience method to send the FTP RNFR command to the server,
1140      * receive the reply, and return the reply code.
1141      * <p>
1142      * @param pathname The pathname to rename from.
1143      * @return The reply code received from the server.
1144      * @exception FTPConnectionClosedException
1145      *      If the FTP server prematurely closes the connection as a result
1146      *      of the client being idle or some other reason causing the server
1147      *      to send FTP reply code 421.  This exception may be caught either
1148      *      as an IOException or independently as itself.
1149      * @exception IOException  If an I/O error occurs while either sending the
1150      *      command or receiving the server reply.
1151      ***/
1152     public int rnfr(String pathname) throws IOException
1153     {
1154         return sendCommand(FTPCommand.RNFR, pathname);
1155     }
1156 
1157     /***
1158      * A convenience method to send the FTP RNTO command to the server,
1159      * receive the reply, and return the reply code.
1160      * <p>
1161      * @param pathname The pathname to rename to
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 rnto(String pathname) throws IOException
1172     {
1173         return sendCommand(FTPCommand.RNTO, pathname);
1174     }
1175 
1176     /***
1177      * A convenience method to send the FTP DELE command to the server,
1178      * receive the reply, and return the reply code.
1179      * <p>
1180      * @param pathname The pathname to delete.
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 dele(String pathname) throws IOException
1191     {
1192         return sendCommand(FTPCommand.DELE, pathname);
1193     }
1194 
1195     /***
1196      * A convenience method to send the FTP RMD command to the server,
1197      * receive the reply, and return the reply code.
1198      * <p>
1199      * @param pathname The pathname of the directory to remove.
1200      * @return The reply code received from the server.
1201      * @exception FTPConnectionClosedException
1202      *      If the FTP server prematurely closes the connection as a result
1203      *      of the client being idle or some other reason causing the server
1204      *      to send FTP reply code 421.  This exception may be caught either
1205      *      as an IOException or independently as itself.
1206      * @exception IOException  If an I/O error occurs while either sending the
1207      *      command or receiving the server reply.
1208      ***/
1209     public int rmd(String pathname) throws IOException
1210     {
1211         return sendCommand(FTPCommand.RMD, pathname);
1212     }
1213 
1214     /***
1215      * A convenience method to send the FTP MKD command to the server,
1216      * receive the reply, and return the reply code.
1217      * <p>
1218      * @param pathname The pathname of the new directory to create.
1219      * @return The reply code received from the server.
1220      * @exception FTPConnectionClosedException
1221      *      If the FTP server prematurely closes the connection as a result
1222      *      of the client being idle or some other reason causing the server
1223      *      to send FTP reply code 421.  This exception may be caught either
1224      *      as an IOException or independently as itself.
1225      * @exception IOException  If an I/O error occurs while either sending the
1226      *      command or receiving the server reply.
1227      ***/
1228     public int mkd(String pathname) throws IOException
1229     {
1230         return sendCommand(FTPCommand.MKD, pathname);
1231     }
1232 
1233     /***
1234      * A convenience method to send the FTP PWD command to the server,
1235      * receive the reply, and return the reply code.
1236      * <p>
1237      * @return The reply code received from the server.
1238      * @exception FTPConnectionClosedException
1239      *      If the FTP server prematurely closes the connection as a result
1240      *      of the client being idle or some other reason causing the server
1241      *      to send FTP reply code 421.  This exception may be caught either
1242      *      as an IOException or independently as itself.
1243      * @exception IOException  If an I/O error occurs while either sending the
1244      *      command or receiving the server reply.
1245      ***/
1246     public int pwd() throws IOException
1247     {
1248         return sendCommand(FTPCommand.PWD);
1249     }
1250 
1251     /***
1252      * A convenience method to send the FTP LIST command to the server,
1253      * receive the reply, and return the reply code.  Remember, it is up
1254      * to you to manage the data connection.  If you don't need this low
1255      * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1256      * , which will handle all low level details for you.
1257      * <p>
1258      * @return The reply code received from the server.
1259      * @exception FTPConnectionClosedException
1260      *      If the FTP server prematurely closes the connection as a result
1261      *      of the client being idle or some other reason causing the server
1262      *      to send FTP reply code 421.  This exception may be caught either
1263      *      as an IOException or independently as itself.
1264      * @exception IOException  If an I/O error occurs while either sending the
1265      *      command or receiving the server reply.
1266      ***/
1267     public int list() throws IOException
1268     {
1269         return sendCommand(FTPCommand.LIST);
1270     }
1271 
1272     /***
1273      * A convenience method to send the FTP LIST command to the server,
1274      * receive the reply, and return the reply code.  Remember, it is up
1275      * to you to manage the data connection.  If you don't need this low
1276      * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1277      * , which will handle all low level details for you.
1278      * <p>
1279      * @param pathname  The pathname to list.
1280      * @return The reply code received from the server.
1281      * @exception FTPConnectionClosedException
1282      *      If the FTP server prematurely closes the connection as a result
1283      *      of the client being idle or some other reason causing the server
1284      *      to send FTP reply code 421.  This exception may be caught either
1285      *      as an IOException or independently as itself.
1286      * @exception IOException  If an I/O error occurs while either sending the
1287      *      command or receiving the server reply.
1288      ***/
1289     public int list(String pathname) throws IOException
1290     {
1291         return sendCommand(FTPCommand.LIST, pathname);
1292     }
1293 
1294     /***
1295      * A convenience method to send the FTP NLST command to the server,
1296      * receive the reply, and return the reply code.  Remember, it is up
1297      * to you to manage the data connection.  If you don't need this low
1298      * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1299      * , which will handle all low level details for you.
1300      * <p>
1301      * @return The reply code received from the server.
1302      * @exception FTPConnectionClosedException
1303      *      If the FTP server prematurely closes the connection as a result
1304      *      of the client being idle or some other reason causing the server
1305      *      to send FTP reply code 421.  This exception may be caught either
1306      *      as an IOException or independently as itself.
1307      * @exception IOException  If an I/O error occurs while either sending the
1308      *      command or receiving the server reply.
1309      ***/
1310     public int nlst() throws IOException
1311     {
1312         return sendCommand(FTPCommand.NLST);
1313     }
1314 
1315     /***
1316      * A convenience method to send the FTP NLST command to the server,
1317      * receive the reply, and return the reply code.  Remember, it is up
1318      * to you to manage the data connection.  If you don't need this low
1319      * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1320      * , which will handle all low level details for you.
1321      * <p>
1322      * @param pathname  The pathname to list.
1323      * @return The reply code received from the server.
1324      * @exception FTPConnectionClosedException
1325      *      If the FTP server prematurely closes the connection as a result
1326      *      of the client being idle or some other reason causing the server
1327      *      to send FTP reply code 421.  This exception may be caught either
1328      *      as an IOException or independently as itself.
1329      * @exception IOException  If an I/O error occurs while either sending the
1330      *      command or receiving the server reply.
1331      ***/
1332     public int nlst(String pathname) throws IOException
1333     {
1334         return sendCommand(FTPCommand.NLST, pathname);
1335     }
1336 
1337     /***
1338      * A convenience method to send the FTP SITE command to the server,
1339      * receive the reply, and return the reply code.
1340      * <p>
1341      * @param parameters  The site parameters to send.
1342      * @return The reply code received from the server.
1343      * @exception FTPConnectionClosedException
1344      *      If the FTP server prematurely closes the connection as a result
1345      *      of the client being idle or some other reason causing the server
1346      *      to send FTP reply code 421.  This exception may be caught either
1347      *      as an IOException or independently as itself.
1348      * @exception IOException  If an I/O error occurs while either sending the
1349      *      command or receiving the server reply.
1350      ***/
1351     public int site(String parameters) throws IOException
1352     {
1353         return sendCommand(FTPCommand.SITE, parameters);
1354     }
1355 
1356     /***
1357      * A convenience method to send the FTP SYST command to the server,
1358      * receive the reply, and return the reply code.
1359      * <p>
1360      * @return The reply code received from the server.
1361      * @exception FTPConnectionClosedException
1362      *      If the FTP server prematurely closes the connection as a result
1363      *      of the client being idle or some other reason causing the server
1364      *      to send FTP reply code 421.  This exception may be caught either
1365      *      as an IOException or independently as itself.
1366      * @exception IOException  If an I/O error occurs while either sending the
1367      *      command or receiving the server reply.
1368      ***/
1369     public int syst() throws IOException
1370     {
1371         return sendCommand(FTPCommand.SYST);
1372     }
1373 
1374     /***
1375      * A convenience method to send the FTP STAT command to the server,
1376      * receive the reply, and return the reply code.
1377      * <p>
1378      * @return The reply code received from the server.
1379      * @exception FTPConnectionClosedException
1380      *      If the FTP server prematurely closes the connection as a result
1381      *      of the client being idle or some other reason causing the server
1382      *      to send FTP reply code 421.  This exception may be caught either
1383      *      as an IOException or independently as itself.
1384      * @exception IOException  If an I/O error occurs while either sending the
1385      *      command or receiving the server reply.
1386      ***/
1387     public int stat() throws IOException
1388     {
1389         return sendCommand(FTPCommand.STAT);
1390     }
1391 
1392     /***
1393      * A convenience method to send the FTP STAT command to the server,
1394      * receive the reply, and return the reply code.
1395      * <p>
1396      * @param pathname  A pathname to list.
1397      * @return The reply code received from the server.
1398      * @exception FTPConnectionClosedException
1399      *      If the FTP server prematurely closes the connection as a result
1400      *      of the client being idle or some other reason causing the server
1401      *      to send FTP reply code 421.  This exception may be caught either
1402      *      as an IOException or independently as itself.
1403      * @exception IOException  If an I/O error occurs while either sending the
1404      *      command or receiving the server reply.
1405      ***/
1406     public int stat(String pathname) throws IOException
1407     {
1408         return sendCommand(FTPCommand.STAT, pathname);
1409     }
1410 
1411     /***
1412      * A convenience method to send the FTP HELP command to the server,
1413      * receive the reply, and return the reply code.
1414      * <p>
1415      * @return The reply code received from the server.
1416      * @exception FTPConnectionClosedException
1417      *      If the FTP server prematurely closes the connection as a result
1418      *      of the client being idle or some other reason causing the server
1419      *      to send FTP reply code 421.  This exception may be caught either
1420      *      as an IOException or independently as itself.
1421      * @exception IOException  If an I/O error occurs while either sending the
1422      *      command or receiving the server reply.
1423      ***/
1424     public int help() throws IOException
1425     {
1426         return sendCommand(FTPCommand.HELP);
1427     }
1428 
1429     /***
1430      * A convenience method to send the FTP HELP command to the server,
1431      * receive the reply, and return the reply code.
1432      * <p>
1433      * @param command  The command name on which to request help.
1434      * @return The reply code received from the server.
1435      * @exception FTPConnectionClosedException
1436      *      If the FTP server prematurely closes the connection as a result
1437      *      of the client being idle or some other reason causing the server
1438      *      to send FTP reply code 421.  This exception may be caught either
1439      *      as an IOException or independently as itself.
1440      * @exception IOException  If an I/O error occurs while either sending the
1441      *      command or receiving the server reply.
1442      ***/
1443     public int help(String command) throws IOException
1444     {
1445         return sendCommand(FTPCommand.HELP, command);
1446     }
1447 
1448     /***
1449      * A convenience method to send the FTP NOOP command to the server,
1450      * receive the reply, and return the reply code.
1451      * <p>
1452      * @return The reply code received from the server.
1453      * @exception FTPConnectionClosedException
1454      *      If the FTP server prematurely closes the connection as a result
1455      *      of the client being idle or some other reason causing the server
1456      *      to send FTP reply code 421.  This exception may be caught either
1457      *      as an IOException or independently as itself.
1458      * @exception IOException  If an I/O error occurs while either sending the
1459      *      command or receiving the server reply.
1460      ***/
1461     public int noop() throws IOException
1462     {
1463         return sendCommand(FTPCommand.NOOP);
1464     }
1465 
1466 }
1467 
1468 /* Emacs configuration
1469  * Local variables:        **
1470  * mode:             java  **
1471  * c-basic-offset:   4     **
1472  * indent-tabs-mode: nil   **
1473  * End:                    **
1474  */