001    /*
002     * Copyright 2001-2005 The Apache Software Foundation
003     *
004     * Licensed under the Apache License, Version 2.0 (the "License");
005     * you may not use this file except in compliance with the License.
006     * You may obtain a copy of the License at
007     *
008     *     http://www.apache.org/licenses/LICENSE-2.0
009     *
010     * Unless required by applicable law or agreed to in writing, software
011     * distributed under the License is distributed on an "AS IS" BASIS,
012     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013     * See the License for the specific language governing permissions and
014     * limitations under the License.
015     */
016    package org.apache.commons.net.ftp;
017    import java.io.BufferedReader;
018    import java.io.BufferedWriter;
019    import java.io.IOException;
020    import java.io.InputStreamReader;
021    import java.io.OutputStreamWriter;
022    import java.lang.reflect.InvocationTargetException;
023    import java.lang.reflect.Method;
024    import java.net.InetAddress;
025    import java.net.Socket;
026    import java.net.SocketException;
027    import java.util.Enumeration;
028    import java.util.Vector;
029    
030    import org.apache.commons.net.MalformedServerReplyException;
031    import org.apache.commons.net.ProtocolCommandListener;
032    import org.apache.commons.net.ProtocolCommandSupport;
033    import org.apache.commons.net.SocketClient;
034    import org.apache.commons.net.telnet.TelnetClient;
035    
036    /***
037     * FTP provides the basic the functionality necessary to implement your
038     * own FTP client.  It extends org.apache.commons.net.TelnetClient
039     * simply because it saves the writing of extra code to handle the FTP
040     * control connection which always remains open during an FTP session and
041     * uses the Telnet protocol.  Aggregation would require writing new
042     * wrapper methods and wouldn't leverage the functionality already
043     * present in org.apache.commons.net.SocketClient.
044     * <p>
045     * To derive the full benefits of the FTP class requires some knowledge
046     * of the FTP protocol defined in RFC 959.  However, there is no reason
047     * why you should have to use the FTP class.  The
048     * {@link org.apache.commons.net.ftp.FTPClient} class,
049     * derived from FTP,
050     * implements all the functionality required of an FTP client.  The
051     * FTP class is made public to provide access to various FTP constants
052     * and to make it easier for adventurous programmers (or those with
053     * special needs) to interact with the FTP protocol and implement their
054     * own clients.  A set of methods with names corresponding to the FTP
055     * command names are provided to facilitate this interaction.
056     * <p>
057     * You should keep in mind that the FTP server may choose to prematurely
058     * close a connection if the client has been idle for longer than a
059     * given time period (usually 900 seconds).  The FTP class will detect a
060     * premature FTP server connection closing when it receives a
061     * {@link org.apache.commons.net.ftp.FTPReply#SERVICE_NOT_AVAILABLE FTPReply.SERVICE_NOT_AVAILABLE }
062     *  response to a command.
063     * When that occurs, the FTP class method encountering that reply will throw
064     * an {@link org.apache.commons.net.ftp.FTPConnectionClosedException}
065     * .  <code>FTPConectionClosedException</code>
066     * is a subclass of <code> IOException </code> and therefore need not be
067     * caught separately, but if you are going to catch it separately, its
068     * catch block must appear before the more general <code> IOException </code>
069     * catch block.  When you encounter an
070     * {@link org.apache.commons.net.ftp.FTPConnectionClosedException}
071     * , you must disconnect the connection with
072     * {@link #disconnect  disconnect() } to properly clean up the
073     * system resources used by FTP.  Before disconnecting, you may check the
074     * last reply code and text with
075     * {@link #getReplyCode  getReplyCode },
076     * {@link #getReplyString  getReplyString },
077     * and {@link #getReplyStrings  getReplyStrings}.
078     * You may avoid server disconnections while the client is idle by
079     * periodicaly sending NOOP commands to the server.
080     * <p>
081     * Rather than list it separately for each method, we mention here that
082     * every method communicating with the server and throwing an IOException
083     * can also throw a
084     * {@link org.apache.commons.net.MalformedServerReplyException}
085     * , which is a subclass
086     * of IOException.  A MalformedServerReplyException will be thrown when
087     * the reply received from the server deviates enough from the protocol
088     * specification that it cannot be interpreted in a useful manner despite
089     * attempts to be as lenient as possible.
090     * <p>
091     * <p>
092     * @author Daniel F. Savarese
093     * @see FTPClient
094     * @see FTPConnectionClosedException
095     * @see org.apache.commons.net.MalformedServerReplyException
096     ***/
097    
098    public class FTP extends TelnetClient
099    {
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     */