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