001 /*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 * http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017
018 package org.apache.commons.net.ftp;
019 import java.io.BufferedReader;
020 import java.io.BufferedWriter;
021 import java.io.IOException;
022 import java.io.InputStreamReader;
023 import java.io.OutputStreamWriter;
024 import java.net.Inet4Address;
025 import java.net.Inet6Address;
026 import java.net.InetAddress;
027 import java.net.Socket;
028 import java.net.SocketException;
029 import java.util.ArrayList;
030
031 import org.apache.commons.net.MalformedServerReplyException;
032 import org.apache.commons.net.ProtocolCommandListener;
033 import org.apache.commons.net.ProtocolCommandSupport;
034 import org.apache.commons.net.SocketClient;
035
036 /***
037 * FTP provides the basic the functionality necessary to implement your
038 * own FTP client. It extends org.apache.commons.net.SocketClient since
039 * extending TelnetClient was causing unwanted behavior (like connections
040 * that did not time out properly).
041 * <p>
042 * To derive the full benefits of the FTP class requires some knowledge
043 * of the FTP protocol defined in RFC 959. However, there is no reason
044 * why you should have to use the FTP class. The
045 * {@link org.apache.commons.net.ftp.FTPClient} class,
046 * derived from FTP,
047 * implements all the functionality required of an FTP client. The
048 * FTP class is made public to provide access to various FTP constants
049 * and to make it easier for adventurous programmers (or those with
050 * special needs) to interact with the FTP protocol and implement their
051 * own clients. A set of methods with names corresponding to the FTP
052 * command names are provided to facilitate this interaction.
053 * <p>
054 * You should keep in mind that the FTP server may choose to prematurely
055 * close a connection if the client has been idle for longer than a
056 * given time period (usually 900 seconds). The FTP class will detect a
057 * premature FTP server connection closing when it receives a
058 * {@link org.apache.commons.net.ftp.FTPReply#SERVICE_NOT_AVAILABLE FTPReply.SERVICE_NOT_AVAILABLE }
059 * response to a command.
060 * When that occurs, the FTP class method encountering that reply will throw
061 * an {@link org.apache.commons.net.ftp.FTPConnectionClosedException}
062 * . <code>FTPConectionClosedException</code>
063 * is a subclass of <code> IOException </code> and therefore need not be
064 * caught separately, but if you are going to catch it separately, its
065 * catch block must appear before the more general <code> IOException </code>
066 * catch block. When you encounter an
067 * {@link org.apache.commons.net.ftp.FTPConnectionClosedException}
068 * , you must disconnect the connection with
069 * {@link #disconnect disconnect() } to properly clean up the
070 * system resources used by FTP. Before disconnecting, you may check the
071 * last reply code and text with
072 * {@link #getReplyCode getReplyCode },
073 * {@link #getReplyString getReplyString },
074 * and {@link #getReplyStrings getReplyStrings}.
075 * You may avoid server disconnections while the client is idle by
076 * periodicaly sending NOOP commands to the server.
077 * <p>
078 * Rather than list it separately for each method, we mention here that
079 * every method communicating with the server and throwing an IOException
080 * can also throw a
081 * {@link org.apache.commons.net.MalformedServerReplyException}
082 * , which is a subclass
083 * of IOException. A MalformedServerReplyException will be thrown when
084 * the reply received from the server deviates enough from the protocol
085 * specification that it cannot be interpreted in a useful manner despite
086 * attempts to be as lenient as possible.
087 * <p>
088 * <p>
089 * @author Daniel F. Savarese
090 * @author Rory Winston
091 * @author Joseph Hindsley
092 * @see FTPClient
093 * @see FTPConnectionClosedException
094 * @see org.apache.commons.net.MalformedServerReplyException
095 * @version $Id: FTP.java 1032954 2010-11-09 12:15:10Z sebb $
096 ***/
097
098 public class FTP extends SocketClient
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 /***
122 * A constant used to indicate the file(s) being transfered should
123 * be treated as a binary image, i.e., no translations should be
124 * performed. All constants ending in <code>FILE_TYPE</code> are used to
125 * indicate file types.
126 ***/
127 public static final int BINARY_FILE_TYPE = 2;
128
129 /***
130 * A constant used to indicate the file(s) being transfered should
131 * be treated as a local type. All constants ending in
132 * <code>FILE_TYPE</code> are used to indicate file types.
133 ***/
134 public static final int LOCAL_FILE_TYPE = 3;
135
136 /***
137 * A constant used for text files to indicate a non-print text format.
138 * This is the default format.
139 * All constants ending in <code>TEXT_FORMAT</code> are used to indicate
140 * text formatting for text transfers (both ASCII and EBCDIC).
141 ***/
142 public static final int NON_PRINT_TEXT_FORMAT = 4;
143
144 /***
145 * A constant used to indicate a text file contains format vertical format
146 * control characters.
147 * All constants ending in <code>TEXT_FORMAT</code> are used to indicate
148 * text formatting for text transfers (both ASCII and EBCDIC).
149 ***/
150 public static final int TELNET_TEXT_FORMAT = 5;
151
152 /***
153 * A constant used to indicate a text file contains ASA vertical format
154 * control characters.
155 * All constants ending in <code>TEXT_FORMAT</code> are used to indicate
156 * text formatting for text transfers (both ASCII and EBCDIC).
157 ***/
158 public static final int CARRIAGE_CONTROL_TEXT_FORMAT = 6;
159
160 /***
161 * A constant used to indicate a file is to be treated as a continuous
162 * sequence of bytes. This is the default structure. All constants ending
163 * in <code>_STRUCTURE</code> are used to indicate file structure for
164 * file transfers.
165 ***/
166 public static final int FILE_STRUCTURE = 7;
167
168 /***
169 * A constant used to indicate a file is to be treated as a sequence
170 * of records. All constants ending in <code>_STRUCTURE</code>
171 * are used to indicate file structure for file transfers.
172 ***/
173 public static final int RECORD_STRUCTURE = 8;
174
175 /***
176 * A constant used to indicate a file is to be treated as a set of
177 * independent indexed pages. All constants ending in
178 * <code>_STRUCTURE</code> are used to indicate file structure for file
179 * transfers.
180 ***/
181 public static final int PAGE_STRUCTURE = 9;
182
183 /***
184 * A constant used to indicate a file is to be transfered as a stream
185 * of bytes. This is the default transfer mode. All constants ending
186 * in <code>TRANSFER_MODE</code> are used to indicate file transfer
187 * modes.
188 ***/
189 public static final int STREAM_TRANSFER_MODE = 10;
190
191 /***
192 * A constant used to indicate a file is to be transfered as a series
193 * of blocks. All constants ending in <code>TRANSFER_MODE</code> are used
194 * to indicate file transfer modes.
195 ***/
196 public static final int BLOCK_TRANSFER_MODE = 11;
197
198 /***
199 * A constant used to indicate a file is to be transfered as FTP
200 * compressed data. All constants ending in <code>TRANSFER_MODE</code>
201 * are used to indicate file transfer modes.
202 ***/
203 public static final int COMPRESSED_TRANSFER_MODE = 12;
204
205 // We have to ensure that the protocol communication is in ASCII
206 // but we use ISO-8859-1 just in case 8-bit characters cross
207 // the wire.
208 /**
209 * The default character encoding used for communicating over an
210 * FTP control connection. The default encoding is an
211 * ASCII-compatible encoding. Some FTP servers expect other
212 * encodings. You can change the encoding used by an FTP instance
213 * with {@link #setControlEncoding setControlEncoding}.
214 */
215 public static final String DEFAULT_CONTROL_ENCODING = "ISO-8859-1";
216 private static final String __modes = "AEILNTCFRPSBC";
217
218 private final StringBuilder __commandBuffer = new StringBuilder();
219
220 protected int _replyCode;
221 protected ArrayList<String> _replyLines;
222 protected boolean _newReplyString;
223 protected String _replyString;
224 protected String _controlEncoding;
225
226 /**
227 * This is used to signal whether a block of multiline responses beginning
228 * with xxx must be terminated by the same numeric code xxx
229 * See section 4.2 of RFC 959 for details.
230 */
231 protected boolean strictMultilineParsing = false;
232
233 /**
234 * Wraps SocketClient._input_ to facilitate the writing of text
235 * to the FTP control connection. Do not access the control
236 * connection via SocketClient._input_. This member starts
237 * with a null value, is initialized in {@link #_connectAction_},
238 * and set to null in {@link #disconnect}.
239 */
240 protected BufferedReader _controlInput_;
241
242 /**
243 * Wraps SocketClient._output_ to facilitate the reading of text
244 * from the FTP control connection. Do not access the control
245 * connection via SocketClient._output_. This member starts
246 * with a null value, is initialized in {@link #_connectAction_},
247 * and set to null in {@link #disconnect}.
248 */
249 protected BufferedWriter _controlOutput_;
250
251 /***
252 * A ProtocolCommandSupport object used to manage the registering of
253 * ProtocolCommandListeners and te firing of ProtocolCommandEvents.
254 ***/
255 protected ProtocolCommandSupport _commandSupport_;
256
257 /***
258 * The default FTP constructor. Sets the default port to
259 * <code>DEFAULT_PORT</code> and initializes internal data structures
260 * for saving FTP reply information.
261 ***/
262 public FTP()
263 {
264 super();
265 setDefaultPort(DEFAULT_PORT);
266 _replyLines = new ArrayList<String>();
267 _newReplyString = false;
268 _replyString = null;
269 _commandSupport_ = new ProtocolCommandSupport(this);
270 _controlEncoding = DEFAULT_CONTROL_ENCODING;
271 }
272
273 // The RFC-compliant multiline termination check
274 private boolean __strictCheck(String line, String code) {
275 return (!(line.startsWith(code) && line.charAt(3) == ' '));
276 }
277
278 // The strict check is too strong a condition because of non-conforming ftp
279 // servers like ftp.funet.fi which sent 226 as the last line of a
280 // 426 multi-line reply in response to ls /. We relax the condition to
281 // test that the line starts with a digit rather than starting with
282 // the code.
283 private boolean __lenientCheck(String line) {
284 return (!(line.length() >= 4 && line.charAt(3) != '-' &&
285 Character.isDigit(line.charAt(0))));
286 }
287
288 private void __getReply() throws IOException
289 {
290 int length;
291
292 _newReplyString = true;
293 _replyLines.clear();
294
295 String line = _controlInput_.readLine();
296
297 if (line == null)
298 throw new FTPConnectionClosedException(
299 "Connection closed without indication.");
300
301 // In case we run into an anomaly we don't want fatal index exceptions
302 // to be thrown.
303 length = line.length();
304 if (length < 3)
305 throw new MalformedServerReplyException(
306 "Truncated server reply: " + line);
307
308 String code = null;
309 try
310 {
311 code = line.substring(0, 3);
312 _replyCode = Integer.parseInt(code);
313 }
314 catch (NumberFormatException e)
315 {
316 throw new MalformedServerReplyException(
317 "Could not parse response code.\nServer Reply: " + line);
318 }
319
320 _replyLines.add(line);
321
322 // Get extra lines if message continues.
323 if (length > 3 && line.charAt(3) == '-')
324 {
325 do
326 {
327 line = _controlInput_.readLine();
328
329 if (line == null)
330 throw new FTPConnectionClosedException(
331 "Connection closed without indication.");
332
333 _replyLines.add(line);
334
335 // The length() check handles problems that could arise from readLine()
336 // returning too soon after encountering a naked CR or some other
337 // anomaly.
338 }
339 while ( isStrictMultilineParsing() ? __strictCheck(line, code) : __lenientCheck(line));
340 }
341
342 if (_commandSupport_.getListenerCount() > 0) {
343 _commandSupport_.fireReplyReceived(_replyCode, getReplyString());
344 }
345
346 if (_replyCode == FTPReply.SERVICE_NOT_AVAILABLE) {
347 throw new FTPConnectionClosedException("FTP response 421 received. Server closed connection.");
348 }
349 }
350
351 /**
352 * Initiates control connections and gets initial reply.
353 * Initializes {@link #_controlInput_} and {@link #_controlOutput_}.
354 */
355 @Override
356 protected void _connectAction_() throws IOException
357 {
358 super._connectAction_();
359 _controlInput_ =
360 new BufferedReader(new InputStreamReader(_socket_.getInputStream(),
361 getControlEncoding()));
362 _controlOutput_ =
363 new BufferedWriter(new OutputStreamWriter(_socket_.getOutputStream(),
364 getControlEncoding()));
365 __getReply();
366 // If we received code 120, we have to fetch completion reply.
367 if (FTPReply.isPositivePreliminary(_replyCode))
368 __getReply();
369 }
370
371
372 /**
373 * Sets the character encoding used by the FTP control connection.
374 * Some FTP servers require that commands be issued in a non-ASCII
375 * encoding like UTF-8 so that filenames with multi-byte character
376 * representations (e.g, Big 8) can be specified.
377 *
378 * @param encoding The new character encoding for the control connection.
379 */
380 public void setControlEncoding(String encoding) {
381 _controlEncoding = encoding;
382 }
383
384
385 /**
386 * @return The character encoding used to communicate over the
387 * control connection.
388 */
389 public String getControlEncoding() {
390 return _controlEncoding;
391 }
392
393
394 /***
395 * Adds a ProtocolCommandListener. Delegates this task to
396 * {@link #_commandSupport_ _commandSupport_ }.
397 * <p>
398 * @param listener The ProtocolCommandListener to add.
399 ***/
400 public void addProtocolCommandListener(ProtocolCommandListener listener)
401 {
402 _commandSupport_.addProtocolCommandListener(listener);
403 }
404
405 /***
406 * Removes a ProtocolCommandListener. Delegates this task to
407 * {@link #_commandSupport_ _commandSupport_ }.
408 * <p>
409 * @param listener The ProtocolCommandListener to remove.
410 ***/
411 public void removeProtocolCommandListener(ProtocolCommandListener listener)
412 {
413 _commandSupport_.removeProtocolCommandListener(listener);
414 }
415
416
417 /***
418 * Closes the control connection to the FTP server and sets to null
419 * some internal data so that the memory may be reclaimed by the
420 * garbage collector. The reply text and code information from the
421 * last command is voided so that the memory it used may be reclaimed.
422 * Also sets {@link #_controlInput_} and {@link #_controlOutput_} to null.
423 * <p>
424 * @exception IOException If an error occurs while disconnecting.
425 ***/
426 @Override
427 public void disconnect() throws IOException
428 {
429 super.disconnect();
430 _controlInput_ = null;
431 _controlOutput_ = null;
432 _newReplyString = false;
433 _replyString = null;
434 }
435
436
437 /***
438 * Sends an FTP command to the server, waits for a reply and returns the
439 * numerical response code. After invocation, for more detailed
440 * information, the actual reply text can be accessed by calling
441 * {@link #getReplyString getReplyString } or
442 * {@link #getReplyStrings getReplyStrings }.
443 * <p>
444 * @param command The text representation of the FTP command to send.
445 * @param args The arguments to the FTP command. If this parameter is
446 * set to null, then the command is sent with no argument.
447 * @return The integer value of the FTP reply code returned by the server
448 * in response to the command.
449 * @exception FTPConnectionClosedException
450 * If the FTP server prematurely closes the connection as a result
451 * of the client being idle or some other reason causing the server
452 * to send FTP reply code 421. This exception may be caught either
453 * as an IOException or independently as itself.
454 * @exception IOException If an I/O error occurs while either sending the
455 * command or receiving the server reply.
456 ***/
457 public int sendCommand(String command, String args) throws IOException
458 {
459 String message;
460
461 __commandBuffer.setLength(0);
462 __commandBuffer.append(command);
463
464 if (args != null)
465 {
466 __commandBuffer.append(' ');
467 __commandBuffer.append(args);
468 }
469 __commandBuffer.append(SocketClient.NETASCII_EOL);
470
471 if (_controlOutput_ == null){
472 throw new IOException("Connection is not open");
473 }
474
475 try{
476 _controlOutput_.write(message = __commandBuffer.toString());
477 _controlOutput_.flush();
478 }
479 catch (SocketException e)
480 {
481 if (!isConnected() || !socketIsConnected(_socket_))
482 {
483 throw new FTPConnectionClosedException("Connection unexpectedly closed.");
484 }
485 else
486 {
487 throw e;
488 }
489 }
490
491
492 if (_commandSupport_.getListenerCount() > 0)
493 _commandSupport_.fireCommandSent(command, message);
494
495 __getReply();
496 return _replyCode;
497 }
498
499 /**
500 * Checks if the socket is connected
501 *
502 * @param socket
503 * @return true if connected
504 */
505 private boolean socketIsConnected(Socket socket)
506 {
507 if (socket == null)
508 {
509 return false;
510 }
511 return socket.isConnected();
512 }
513
514 /***
515 * Sends an FTP command to the server, waits for a reply and returns the
516 * numerical response code. After invocation, for more detailed
517 * information, the actual reply text can be accessed by calling
518 * {@link #getReplyString getReplyString } or
519 * {@link #getReplyStrings getReplyStrings }.
520 * <p>
521 * @param command The FTPCommand constant corresponding to the FTP command
522 * to send.
523 * @param args The arguments to the FTP command. If this parameter is
524 * set to null, then the command is sent with no argument.
525 * @return The integer value of the FTP reply code returned by the server
526 * in response to the command.
527 * @exception FTPConnectionClosedException
528 * If the FTP server prematurely closes the connection as a result
529 * of the client being idle or some other reason causing the server
530 * to send FTP reply code 421. This exception may be caught either
531 * as an IOException or independently as itself.
532 * @exception IOException If an I/O error occurs while either sending the
533 * command or receiving the server reply.
534 ***/
535 public int sendCommand(int command, String args) throws IOException
536 {
537 return sendCommand(FTPCommand.getCommand(command), args);
538 }
539
540
541 /***
542 * Sends an FTP command with no arguments to the server, waits for a
543 * reply and returns the numerical response code. After invocation, for
544 * more detailed information, the actual reply text can be accessed by
545 * calling {@link #getReplyString getReplyString } or
546 * {@link #getReplyStrings getReplyStrings }.
547 * <p>
548 * @param command The text representation of the FTP command to send.
549 * @return The integer value of the FTP reply code returned by the server
550 * in response to the command.
551 * @exception FTPConnectionClosedException
552 * If the FTP server prematurely closes the connection as a result
553 * of the client being idle or some other reason causing the server
554 * to send FTP reply code 421. This exception may be caught either
555 * as an IOException or independently as itself.
556 * @exception IOException If an I/O error occurs while either sending the
557 * command or receiving the server reply.
558 ***/
559 public int sendCommand(String command) throws IOException
560 {
561 return sendCommand(command, null);
562 }
563
564
565 /***
566 * Sends an FTP command with no arguments to the server, waits for a
567 * reply and returns the numerical response code. After invocation, for
568 * more detailed information, the actual reply text can be accessed by
569 * calling {@link #getReplyString getReplyString } or
570 * {@link #getReplyStrings getReplyStrings }.
571 * <p>
572 * @param command The FTPCommand constant corresponding to the FTP command
573 * to send.
574 * @return The integer value of the FTP reply code returned by the server
575 * in response to the command.
576 * @exception FTPConnectionClosedException
577 * If the FTP server prematurely closes the connection as a result
578 * of the client being idle or some other reason causing the server
579 * to send FTP reply code 421. This exception may be caught either
580 * as an IOException or independently as itself.
581 * @exception IOException If an I/O error occurs while either sending the
582 * command or receiving the server reply.
583 ***/
584 public int sendCommand(int command) throws IOException
585 {
586 return sendCommand(command, null);
587 }
588
589
590 /***
591 * Returns the integer value of the reply code of the last FTP reply.
592 * You will usually only use this method after you connect to the
593 * FTP server to check that the connection was successful since
594 * <code> connect </code> is of type void.
595 * <p>
596 * @return The integer value of the reply code of the last FTP reply.
597 ***/
598 public int getReplyCode()
599 {
600 return _replyCode;
601 }
602
603 /***
604 * Fetches a reply from the FTP server and returns the integer reply
605 * code. After calling this method, the actual reply text can be accessed
606 * from either calling {@link #getReplyString getReplyString } or
607 * {@link #getReplyStrings getReplyStrings }. Only use this
608 * method if you are implementing your own FTP client or if you need to
609 * fetch a secondary response from the FTP server.
610 * <p>
611 * @return The integer value of the reply code of the fetched FTP reply.
612 * @exception FTPConnectionClosedException
613 * If the FTP server prematurely closes the connection as a result
614 * of the client being idle or some other reason causing the server
615 * to send FTP reply code 421. This exception may be caught either
616 * as an IOException or independently as itself.
617 * @exception IOException If an I/O error occurs while receiving the
618 * server reply.
619 ***/
620 public int getReply() throws IOException
621 {
622 __getReply();
623 return _replyCode;
624 }
625
626
627 /***
628 * Returns the lines of text from the last FTP server response as an array
629 * of strings, one entry per line. The end of line markers of each are
630 * stripped from each line.
631 * <p>
632 * @return The lines of text from the last FTP response as an array.
633 ***/
634 public String[] getReplyStrings()
635 {
636 return _replyLines.toArray(new String[_replyLines.size()]);
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 StringBuilder info = new StringBuilder(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 EPRT command to the server,
867 * receive the reply, and return the reply code.
868 *
869 * Examples:
870 * <code>
871 * <ul>
872 * <li>EPRT |1|132.235.1.2|6275|</li>
873 * <li>EPRT |2|1080::8:800:200C:417A|5282|</li>
874 * </ul>
875 * </code>
876 * <p>
877 * @see "http://www.faqs.org/rfcs/rfc2428.html"
878 *
879 * @param host The host owning the port.
880 * @param port The new port.
881 * @return The reply code received from the server.
882 * @exception FTPConnectionClosedException
883 * If the FTP server prematurely closes the connection as a result
884 * of the client being idle or some other reason causing the server
885 * to send FTP reply code 421. This exception may be caught either
886 * as an IOException or independently as itself.
887 * @exception IOException If an I/O error occurs while either sending the
888 * command or receiving the server reply.
889 * @since 2.2
890 ***/
891 public int eprt(InetAddress host, int port) throws IOException
892 {
893 int num;
894 StringBuilder info = new StringBuilder();
895 String h;
896
897 // If IPv6, trim the zone index
898 h = host.getHostAddress();
899 num = h.indexOf("%");
900 if (num > 0)
901 h = h.substring(0, num);
902
903 info.append("|");
904
905 if (host instanceof Inet4Address)
906 info.append("1");
907 else if (host instanceof Inet6Address)
908 info.append("2");
909 info.append("|");
910 info.append(h);
911 info.append("|");
912 info.append(port);
913 info.append("|");
914
915 return sendCommand(FTPCommand.EPRT, info.toString());
916 }
917
918 /***
919 * A convenience method to send the FTP PASV command to the server,
920 * receive the reply, and return the reply code. Remember, it's up
921 * to you to interpret the reply string containing the host/port
922 * information.
923 * <p>
924 * @return The reply code received from the server.
925 * @exception FTPConnectionClosedException
926 * If the FTP server prematurely closes the connection as a result
927 * of the client being idle or some other reason causing the server
928 * to send FTP reply code 421. This exception may be caught either
929 * as an IOException or independently as itself.
930 * @exception IOException If an I/O error occurs while either sending the
931 * command or receiving the server reply.
932 ***/
933 public int pasv() throws IOException
934 {
935 return sendCommand(FTPCommand.PASV);
936 }
937
938 /***
939 * A convenience method to send the FTP EPSV command to the server,
940 * receive the reply, and return the reply code. Remember, it's up
941 * to you to interpret the reply string containing the host/port
942 * information.
943 * <p>
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 * @since 2.2
953 ***/
954 public int epsv() throws IOException
955 {
956 return sendCommand(FTPCommand.EPSV);
957 }
958
959 /**
960 * A convenience method to send the FTP TYPE command for text files
961 * to the server, receive the reply, and return the reply code.
962 * @param fileType The type of the file (one of the <code>FILE_TYPE</code>
963 * constants).
964 * @param formatOrByteSize The format of the file (one of the
965 * <code>_FORMAT</code> constants. In the case of
966 * <code>LOCAL_FILE_TYPE</code>, the byte size.
967 * @return The reply code received from the server.
968 * @exception FTPConnectionClosedException
969 * If the FTP server prematurely closes the connection as a result
970 * of the client being idle or some other reason causing the server
971 * to send FTP reply code 421. This exception may be caught either
972 * as an IOException or independently as itself.
973 * @exception IOException If an I/O error occurs while either sending the
974 * command or receiving the server reply.
975 */
976 public int type(int fileType, int formatOrByteSize) throws IOException
977 {
978 StringBuilder arg = new StringBuilder();
979
980 arg.append(__modes.charAt(fileType));
981 arg.append(' ');
982 if (fileType == LOCAL_FILE_TYPE)
983 arg.append(formatOrByteSize);
984 else
985 arg.append(__modes.charAt(formatOrByteSize));
986
987 return sendCommand(FTPCommand.TYPE, arg.toString());
988 }
989
990
991 /**
992 * A convenience method to send the FTP TYPE command to the server,
993 * receive the reply, and return the reply code.
994 * <p>
995 * @param fileType The type of the file (one of the <code>FILE_TYPE</code>
996 * constants).
997 * @return The reply code received from the server.
998 * @exception FTPConnectionClosedException
999 * If the FTP server prematurely closes the connection as a result
1000 * of the client being idle or some other reason causing the server
1001 * to send FTP reply code 421. This exception may be caught either
1002 * as an IOException or independently as itself.
1003 * @exception IOException If an I/O error occurs while either sending the
1004 * command or receiving the server reply.
1005 */
1006 public int type(int fileType) throws IOException
1007 {
1008 return sendCommand(FTPCommand.TYPE,
1009 __modes.substring(fileType, fileType + 1));
1010 }
1011
1012 /***
1013 * A convenience method to send the FTP STRU command to the server,
1014 * receive the reply, and return the reply code.
1015 * <p>
1016 * @param structure The structure of the file (one of the
1017 * <code>_STRUCTURE</code> constants).
1018 * @return The reply code received from the server.
1019 * @exception FTPConnectionClosedException
1020 * If the FTP server prematurely closes the connection as a result
1021 * of the client being idle or some other reason causing the server
1022 * to send FTP reply code 421. This exception may be caught either
1023 * as an IOException or independently as itself.
1024 * @exception IOException If an I/O error occurs while either sending the
1025 * command or receiving the server reply.
1026 ***/
1027 public int stru(int structure) throws IOException
1028 {
1029 return sendCommand(FTPCommand.STRU,
1030 __modes.substring(structure, structure + 1));
1031 }
1032
1033 /***
1034 * A convenience method to send the FTP MODE command to the server,
1035 * receive the reply, and return the reply code.
1036 * <p>
1037 * @param mode The transfer mode to use (one of the
1038 * <code>TRANSFER_MODE</code> constants).
1039 * @return The reply code received from the server.
1040 * @exception FTPConnectionClosedException
1041 * If the FTP server prematurely closes the connection as a result
1042 * of the client being idle or some other reason causing the server
1043 * to send FTP reply code 421. This exception may be caught either
1044 * as an IOException or independently as itself.
1045 * @exception IOException If an I/O error occurs while either sending the
1046 * command or receiving the server reply.
1047 ***/
1048 public int mode(int mode) throws IOException
1049 {
1050 return sendCommand(FTPCommand.MODE,
1051 __modes.substring(mode, mode + 1));
1052 }
1053
1054 /***
1055 * A convenience method to send the FTP RETR command to the server,
1056 * receive the reply, and return the reply code. Remember, it is up
1057 * to you to manage the data connection. If you don't need this low
1058 * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1059 * , which will handle all low level details for you.
1060 * <p>
1061 * @param pathname The pathname of the file to retrieve.
1062 * @return The reply code received from the server.
1063 * @exception FTPConnectionClosedException
1064 * If the FTP server prematurely closes the connection as a result
1065 * of the client being idle or some other reason causing the server
1066 * to send FTP reply code 421. This exception may be caught either
1067 * as an IOException or independently as itself.
1068 * @exception IOException If an I/O error occurs while either sending the
1069 * command or receiving the server reply.
1070 ***/
1071 public int retr(String pathname) throws IOException
1072 {
1073 return sendCommand(FTPCommand.RETR, pathname);
1074 }
1075
1076 /***
1077 * A convenience method to send the FTP STOR command to the server,
1078 * receive the reply, and return the reply code. Remember, it is up
1079 * to you to manage the data connection. If you don't need this low
1080 * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1081 * , which will handle all low level details for you.
1082 * <p>
1083 * @param pathname The pathname to use for the file when stored at
1084 * the remote end of the transfer.
1085 * @return The reply code received from the server.
1086 * @exception FTPConnectionClosedException
1087 * If the FTP server prematurely closes the connection as a result
1088 * of the client being idle or some other reason causing the server
1089 * to send FTP reply code 421. This exception may be caught either
1090 * as an IOException or independently as itself.
1091 * @exception IOException If an I/O error occurs while either sending the
1092 * command or receiving the server reply.
1093 ***/
1094 public int stor(String pathname) throws IOException
1095 {
1096 return sendCommand(FTPCommand.STOR, pathname);
1097 }
1098
1099 /***
1100 * A convenience method to send the FTP STOU command to the server,
1101 * receive the reply, and return the reply code. Remember, it is up
1102 * to you to manage the data connection. If you don't need this low
1103 * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1104 * , which will handle all low level details for you.
1105 * <p>
1106 * @return The reply code received from the server.
1107 * @exception FTPConnectionClosedException
1108 * If the FTP server prematurely closes the connection as a result
1109 * of the client being idle or some other reason causing the server
1110 * to send FTP reply code 421. This exception may be caught either
1111 * as an IOException or independently as itself.
1112 * @exception IOException If an I/O error occurs while either sending the
1113 * command or receiving the server reply.
1114 ***/
1115 public int stou() throws IOException
1116 {
1117 return sendCommand(FTPCommand.STOU);
1118 }
1119
1120 /***
1121 * A convenience method to send the FTP STOU command to the server,
1122 * receive the reply, and return the reply code. Remember, it is up
1123 * to you to manage the data connection. If you don't need this low
1124 * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1125 * , which will handle all low level details for you.
1126 * @param pathname The base pathname to use for the file when stored at
1127 * the remote end of the transfer. Some FTP servers
1128 * require this.
1129 * @return The reply code received from the server.
1130 * @exception FTPConnectionClosedException
1131 * If the FTP server prematurely closes the connection as a result
1132 * of the client being idle or some other reason causing the server
1133 * to send FTP reply code 421. This exception may be caught either
1134 * as an IOException or independently as itself.
1135 * @exception IOException If an I/O error occurs while either sending the
1136 * command or receiving the server reply.
1137 */
1138 public int stou(String pathname) throws IOException
1139 {
1140 return sendCommand(FTPCommand.STOU, pathname);
1141 }
1142
1143 /***
1144 * A convenience method to send the FTP APPE command to the server,
1145 * receive the reply, and return the reply code. Remember, it is up
1146 * to you to manage the data connection. If you don't need this low
1147 * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1148 * , which will handle all low level details for you.
1149 * <p>
1150 * @param pathname The pathname to use for the file when stored at
1151 * the remote end of the transfer.
1152 * @return The reply code received from the server.
1153 * @exception FTPConnectionClosedException
1154 * If the FTP server prematurely closes the connection as a result
1155 * of the client being idle or some other reason causing the server
1156 * to send FTP reply code 421. This exception may be caught either
1157 * as an IOException or independently as itself.
1158 * @exception IOException If an I/O error occurs while either sending the
1159 * command or receiving the server reply.
1160 ***/
1161 public int appe(String pathname) throws IOException
1162 {
1163 return sendCommand(FTPCommand.APPE, pathname);
1164 }
1165
1166 /***
1167 * A convenience method to send the FTP ALLO command to the server,
1168 * receive the reply, and return the reply code.
1169 * <p>
1170 * @param bytes The number of bytes to allocate.
1171 * @return The reply code received from the server.
1172 * @exception FTPConnectionClosedException
1173 * If the FTP server prematurely closes the connection as a result
1174 * of the client being idle or some other reason causing the server
1175 * to send FTP reply code 421. This exception may be caught either
1176 * as an IOException or independently as itself.
1177 * @exception IOException If an I/O error occurs while either sending the
1178 * command or receiving the server reply.
1179 ***/
1180 public int allo(int bytes) throws IOException
1181 {
1182 return sendCommand(FTPCommand.ALLO, Integer.toString(bytes));
1183 }
1184
1185 /**
1186 * A convenience method to send the FTP FEAT command to the server, receive the reply,
1187 * and return the reply code.
1188 * @return The reply code received by the server
1189 * @throws IOException If an I/O error occurs while either sending the
1190 * command or receiving the server reply.
1191 * @since 2.2
1192 */
1193 public int feat() throws IOException
1194 {
1195 return sendCommand(FTPCommand.FEAT);
1196 }
1197
1198 /***
1199 * A convenience method to send the FTP ALLO command to the server,
1200 * receive the reply, and return the reply code.
1201 * <p>
1202 * @param bytes The number of bytes to allocate.
1203 * @param recordSize The size of a record.
1204 * @return The reply code received from the server.
1205 * @exception FTPConnectionClosedException
1206 * If the FTP server prematurely closes the connection as a result
1207 * of the client being idle or some other reason causing the server
1208 * to send FTP reply code 421. This exception may be caught either
1209 * as an IOException or independently as itself.
1210 * @exception IOException If an I/O error occurs while either sending the
1211 * command or receiving the server reply.
1212 ***/
1213 public int allo(int bytes, int recordSize) throws IOException
1214 {
1215 return sendCommand(FTPCommand.ALLO, Integer.toString(bytes) + " R " +
1216 Integer.toString(recordSize));
1217 }
1218
1219 /***
1220 * A convenience method to send the FTP REST command to the server,
1221 * receive the reply, and return the reply code.
1222 * <p>
1223 * @param marker The marker at which to restart a transfer.
1224 * @return The reply code received from the server.
1225 * @exception FTPConnectionClosedException
1226 * If the FTP server prematurely closes the connection as a result
1227 * of the client being idle or some other reason causing the server
1228 * to send FTP reply code 421. This exception may be caught either
1229 * as an IOException or independently as itself.
1230 * @exception IOException If an I/O error occurs while either sending the
1231 * command or receiving the server reply.
1232 ***/
1233 public int rest(String marker) throws IOException
1234 {
1235 return sendCommand(FTPCommand.REST, marker);
1236 }
1237
1238
1239 /**
1240 * @since 2.0
1241 **/
1242 public int mdtm(String file) throws IOException
1243 {
1244 return sendCommand(FTPCommand.MDTM, file);
1245 }
1246
1247
1248 /**
1249 * A convenience method to send the FTP MFMT command to the server,
1250 * receive the reply, and return the reply code.
1251 * <p>
1252 * @param pathname The pathname for which mtime is to be changed
1253 * @param timeval Timestamp in <code>YYYYMMDDhhmmss</code> format
1254 * @return The reply code received from the server.
1255 * @exception FTPConnectionClosedException
1256 * If the FTP server prematurely closes the connection as a result
1257 * of the client being idle or some other reason causing the server
1258 * to send FTP reply code 421. This exception may be caught either
1259 * as an IOException or independently as itself.
1260 * @exception IOException If an I/O error occurs while either sending the
1261 * command or receiving the server reply.
1262 * @since 2.2
1263 * @see <a href="http://tools.ietf.org/html/draft-somers-ftp-mfxx-04">http://tools.ietf.org/html/draft-somers-ftp-mfxx-04</a>
1264 **/
1265 public int mfmt(String pathname, String timeval) throws IOException
1266 {
1267 return sendCommand(FTPCommand.MFMT, timeval + " " + pathname);
1268 }
1269
1270
1271 /***
1272 * A convenience method to send the FTP RNFR command to the server,
1273 * receive the reply, and return the reply code.
1274 * <p>
1275 * @param pathname The pathname to rename from.
1276 * @return The reply code received from the server.
1277 * @exception FTPConnectionClosedException
1278 * If the FTP server prematurely closes the connection as a result
1279 * of the client being idle or some other reason causing the server
1280 * to send FTP reply code 421. This exception may be caught either
1281 * as an IOException or independently as itself.
1282 * @exception IOException If an I/O error occurs while either sending the
1283 * command or receiving the server reply.
1284 ***/
1285 public int rnfr(String pathname) throws IOException
1286 {
1287 return sendCommand(FTPCommand.RNFR, pathname);
1288 }
1289
1290 /***
1291 * A convenience method to send the FTP RNTO command to the server,
1292 * receive the reply, and return the reply code.
1293 * <p>
1294 * @param pathname The pathname to rename to
1295 * @return The reply code received from the server.
1296 * @exception FTPConnectionClosedException
1297 * If the FTP server prematurely closes the connection as a result
1298 * of the client being idle or some other reason causing the server
1299 * to send FTP reply code 421. This exception may be caught either
1300 * as an IOException or independently as itself.
1301 * @exception IOException If an I/O error occurs while either sending the
1302 * command or receiving the server reply.
1303 ***/
1304 public int rnto(String pathname) throws IOException
1305 {
1306 return sendCommand(FTPCommand.RNTO, pathname);
1307 }
1308
1309 /***
1310 * A convenience method to send the FTP DELE command to the server,
1311 * receive the reply, and return the reply code.
1312 * <p>
1313 * @param pathname The pathname to delete.
1314 * @return The reply code received from the server.
1315 * @exception FTPConnectionClosedException
1316 * If the FTP server prematurely closes the connection as a result
1317 * of the client being idle or some other reason causing the server
1318 * to send FTP reply code 421. This exception may be caught either
1319 * as an IOException or independently as itself.
1320 * @exception IOException If an I/O error occurs while either sending the
1321 * command or receiving the server reply.
1322 ***/
1323 public int dele(String pathname) throws IOException
1324 {
1325 return sendCommand(FTPCommand.DELE, pathname);
1326 }
1327
1328 /***
1329 * A convenience method to send the FTP RMD command to the server,
1330 * receive the reply, and return the reply code.
1331 * <p>
1332 * @param pathname The pathname of the directory to remove.
1333 * @return The reply code received from the server.
1334 * @exception FTPConnectionClosedException
1335 * If the FTP server prematurely closes the connection as a result
1336 * of the client being idle or some other reason causing the server
1337 * to send FTP reply code 421. This exception may be caught either
1338 * as an IOException or independently as itself.
1339 * @exception IOException If an I/O error occurs while either sending the
1340 * command or receiving the server reply.
1341 ***/
1342 public int rmd(String pathname) throws IOException
1343 {
1344 return sendCommand(FTPCommand.RMD, pathname);
1345 }
1346
1347 /***
1348 * A convenience method to send the FTP MKD command to the server,
1349 * receive the reply, and return the reply code.
1350 * <p>
1351 * @param pathname The pathname of the new directory to create.
1352 * @return The reply code received from the server.
1353 * @exception FTPConnectionClosedException
1354 * If the FTP server prematurely closes the connection as a result
1355 * of the client being idle or some other reason causing the server
1356 * to send FTP reply code 421. This exception may be caught either
1357 * as an IOException or independently as itself.
1358 * @exception IOException If an I/O error occurs while either sending the
1359 * command or receiving the server reply.
1360 ***/
1361 public int mkd(String pathname) throws IOException
1362 {
1363 return sendCommand(FTPCommand.MKD, pathname);
1364 }
1365
1366 /***
1367 * A convenience method to send the FTP PWD command to the server,
1368 * receive the reply, and return the reply code.
1369 * <p>
1370 * @return The reply code received from the server.
1371 * @exception FTPConnectionClosedException
1372 * If the FTP server prematurely closes the connection as a result
1373 * of the client being idle or some other reason causing the server
1374 * to send FTP reply code 421. This exception may be caught either
1375 * as an IOException or independently as itself.
1376 * @exception IOException If an I/O error occurs while either sending the
1377 * command or receiving the server reply.
1378 ***/
1379 public int pwd() throws IOException
1380 {
1381 return sendCommand(FTPCommand.PWD);
1382 }
1383
1384 /***
1385 * A convenience method to send the FTP LIST command to the server,
1386 * receive the reply, and return the reply code. Remember, it is up
1387 * to you to manage the data connection. If you don't need this low
1388 * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1389 * , which will handle all low level details for you.
1390 * <p>
1391 * @return The reply code received from the server.
1392 * @exception FTPConnectionClosedException
1393 * If the FTP server prematurely closes the connection as a result
1394 * of the client being idle or some other reason causing the server
1395 * to send FTP reply code 421. This exception may be caught either
1396 * as an IOException or independently as itself.
1397 * @exception IOException If an I/O error occurs while either sending the
1398 * command or receiving the server reply.
1399 ***/
1400 public int list() throws IOException
1401 {
1402 return sendCommand(FTPCommand.LIST);
1403 }
1404
1405 /***
1406 * A convenience method to send the FTP LIST command to the server,
1407 * receive the reply, and return the reply code. Remember, it is up
1408 * to you to manage the data connection. If you don't need this low
1409 * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1410 * , which will handle all low level details for you.
1411 * <p>
1412 * @param pathname The pathname to list.
1413 * @return The reply code received from the server.
1414 * @exception FTPConnectionClosedException
1415 * If the FTP server prematurely closes the connection as a result
1416 * of the client being idle or some other reason causing the server
1417 * to send FTP reply code 421. This exception may be caught either
1418 * as an IOException or independently as itself.
1419 * @exception IOException If an I/O error occurs while either sending the
1420 * command or receiving the server reply.
1421 ***/
1422 public int list(String pathname) throws IOException
1423 {
1424 return sendCommand(FTPCommand.LIST, pathname);
1425 }
1426
1427 /***
1428 * A convenience method to send the FTP NLST command to the server,
1429 * receive the reply, and return the reply code. Remember, it is up
1430 * to you to manage the data connection. If you don't need this low
1431 * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1432 * , which will handle all low level details for you.
1433 * <p>
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 nlst() throws IOException
1444 {
1445 return sendCommand(FTPCommand.NLST);
1446 }
1447
1448 /***
1449 * A convenience method to send the FTP NLST command to the server,
1450 * receive the reply, and return the reply code. Remember, it is up
1451 * to you to manage the data connection. If you don't need this low
1452 * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1453 * , which will handle all low level details for you.
1454 * <p>
1455 * @param pathname The pathname to list.
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 nlst(String pathname) throws IOException
1466 {
1467 return sendCommand(FTPCommand.NLST, pathname);
1468 }
1469
1470 /***
1471 * A convenience method to send the FTP SITE command to the server,
1472 * receive the reply, and return the reply code.
1473 * <p>
1474 * @param parameters The site parameters to send.
1475 * @return The reply code received from the server.
1476 * @exception FTPConnectionClosedException
1477 * If the FTP server prematurely closes the connection as a result
1478 * of the client being idle or some other reason causing the server
1479 * to send FTP reply code 421. This exception may be caught either
1480 * as an IOException or independently as itself.
1481 * @exception IOException If an I/O error occurs while either sending the
1482 * command or receiving the server reply.
1483 ***/
1484 public int site(String parameters) throws IOException
1485 {
1486 return sendCommand(FTPCommand.SITE, parameters);
1487 }
1488
1489 /***
1490 * A convenience method to send the FTP SYST command to the server,
1491 * receive the reply, and return the reply code.
1492 * <p>
1493 * @return The reply code received from the server.
1494 * @exception FTPConnectionClosedException
1495 * If the FTP server prematurely closes the connection as a result
1496 * of the client being idle or some other reason causing the server
1497 * to send FTP reply code 421. This exception may be caught either
1498 * as an IOException or independently as itself.
1499 * @exception IOException If an I/O error occurs while either sending the
1500 * command or receiving the server reply.
1501 ***/
1502 public int syst() throws IOException
1503 {
1504 return sendCommand(FTPCommand.SYST);
1505 }
1506
1507 /***
1508 * A convenience method to send the FTP STAT command to the server,
1509 * receive the reply, and return the reply code.
1510 * <p>
1511 * @return The reply code received from the server.
1512 * @exception FTPConnectionClosedException
1513 * If the FTP server prematurely closes the connection as a result
1514 * of the client being idle or some other reason causing the server
1515 * to send FTP reply code 421. This exception may be caught either
1516 * as an IOException or independently as itself.
1517 * @exception IOException If an I/O error occurs while either sending the
1518 * command or receiving the server reply.
1519 ***/
1520 public int stat() throws IOException
1521 {
1522 return sendCommand(FTPCommand.STAT);
1523 }
1524
1525 /***
1526 * A convenience method to send the FTP STAT command to the server,
1527 * receive the reply, and return the reply code.
1528 * <p>
1529 * @param pathname A pathname to list.
1530 * @return The reply code received from the server.
1531 * @exception FTPConnectionClosedException
1532 * If the FTP server prematurely closes the connection as a result
1533 * of the client being idle or some other reason causing the server
1534 * to send FTP reply code 421. This exception may be caught either
1535 * as an IOException or independently as itself.
1536 * @exception IOException If an I/O error occurs while either sending the
1537 * command or receiving the server reply.
1538 ***/
1539 public int stat(String pathname) throws IOException
1540 {
1541 return sendCommand(FTPCommand.STAT, pathname);
1542 }
1543
1544 /***
1545 * A convenience method to send the FTP HELP command to the server,
1546 * receive the reply, and return the reply code.
1547 * <p>
1548 * @return The reply code received from the server.
1549 * @exception FTPConnectionClosedException
1550 * If the FTP server prematurely closes the connection as a result
1551 * of the client being idle or some other reason causing the server
1552 * to send FTP reply code 421. This exception may be caught either
1553 * as an IOException or independently as itself.
1554 * @exception IOException If an I/O error occurs while either sending the
1555 * command or receiving the server reply.
1556 ***/
1557 public int help() throws IOException
1558 {
1559 return sendCommand(FTPCommand.HELP);
1560 }
1561
1562 /***
1563 * A convenience method to send the FTP HELP command to the server,
1564 * receive the reply, and return the reply code.
1565 * <p>
1566 * @param command The command name on which to request help.
1567 * @return The reply code received from the server.
1568 * @exception FTPConnectionClosedException
1569 * If the FTP server prematurely closes the connection as a result
1570 * of the client being idle or some other reason causing the server
1571 * to send FTP reply code 421. This exception may be caught either
1572 * as an IOException or independently as itself.
1573 * @exception IOException If an I/O error occurs while either sending the
1574 * command or receiving the server reply.
1575 ***/
1576 public int help(String command) throws IOException
1577 {
1578 return sendCommand(FTPCommand.HELP, command);
1579 }
1580
1581 /***
1582 * A convenience method to send the FTP NOOP command to the server,
1583 * receive the reply, and return the reply code.
1584 * <p>
1585 * @return The reply code received from the server.
1586 * @exception FTPConnectionClosedException
1587 * If the FTP server prematurely closes the connection as a result
1588 * of the client being idle or some other reason causing the server
1589 * to send FTP reply code 421. This exception may be caught either
1590 * as an IOException or independently as itself.
1591 * @exception IOException If an I/O error occurs while either sending the
1592 * command or receiving the server reply.
1593 ***/
1594 public int noop() throws IOException
1595 {
1596 return sendCommand(FTPCommand.NOOP);
1597 }
1598
1599 /**
1600 * Return whether strict multiline parsing is enabled, as per RFC 959, section 4.2.
1601 * @return True if strict, false if lenient
1602 * @since 2.0
1603 */
1604 public boolean isStrictMultilineParsing() {
1605 return strictMultilineParsing;
1606 }
1607
1608 /**
1609 * Set strict multiline parsing.
1610 * @param strictMultilineParsing
1611 * @since 2.0
1612 */
1613 public void setStrictMultilineParsing(boolean strictMultilineParsing) {
1614 this.strictMultilineParsing = strictMultilineParsing;
1615 }
1616 }
1617
1618 /* Emacs configuration
1619 * Local variables: **
1620 * mode: java **
1621 * c-basic-offset: 4 **
1622 * indent-tabs-mode: nil **
1623 * End: **
1624 */