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 public static final int IMAGE_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 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 RFX 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 try{
472 _controlOutput_.write(message = __commandBuffer.toString());
473 _controlOutput_.flush();
474 }
475 catch (SocketException e)
476 {
477 if (!isConnected() || !socketIsConnected(_socket_))
478 {
479 throw new FTPConnectionClosedException("Connection unexpectedly closed.");
480 }
481 else
482 {
483 throw e;
484 }
485 }
486
487
488 if (_commandSupport_.getListenerCount() > 0)
489 _commandSupport_.fireCommandSent(command, message);
490
491 __getReply();
492 return _replyCode;
493 }
494
495 /**
496 * Checks if the socket is connected
497 *
498 * @param socket
499 * @return true if connected
500 */
501 private boolean socketIsConnected(Socket socket)
502 {
503 if (socket == null)
504 {
505 return false;
506 }
507
508 return socket.isConnected();
509
510 }
511
512 /***
513 * Sends an FTP command to the server, waits for a reply and returns the
514 * numerical response code. After invocation, for more detailed
515 * information, the actual reply text can be accessed by calling
516 * {@link #getReplyString getReplyString } or
517 * {@link #getReplyStrings getReplyStrings }.
518 * <p>
519 * @param command The FTPCommand constant corresponding to the FTP command
520 * to send.
521 * @param args The arguments to the FTP command. If this parameter is
522 * set to null, then the command is sent with no argument.
523 * @return The integer value of the FTP reply code returned by the server
524 * in response to the command.
525 * @exception FTPConnectionClosedException
526 * If the FTP server prematurely closes the connection as a result
527 * of the client being idle or some other reason causing the server
528 * to send FTP reply code 421. This exception may be caught either
529 * as an IOException or independently as itself.
530 * @exception IOException If an I/O error occurs while either sending the
531 * command or receiving the server reply.
532 ***/
533 public int sendCommand(int command, String args) throws IOException
534 {
535 return sendCommand(FTPCommand._commands[command], args);
536 }
537
538
539 /***
540 * Sends an FTP command with no arguments to the server, waits for a
541 * reply and returns the numerical response code. After invocation, for
542 * more detailed information, the actual reply text can be accessed by
543 * calling {@link #getReplyString getReplyString } or
544 * {@link #getReplyStrings getReplyStrings }.
545 * <p>
546 * @param command The text representation of the FTP command to send.
547 * @return The integer value of the FTP reply code returned by the server
548 * in response to the command.
549 * @exception FTPConnectionClosedException
550 * If the FTP server prematurely closes the connection as a result
551 * of the client being idle or some other reason causing the server
552 * to send FTP reply code 421. This exception may be caught either
553 * as an IOException or independently as itself.
554 * @exception IOException If an I/O error occurs while either sending the
555 * command or receiving the server reply.
556 ***/
557 public int sendCommand(String command) throws IOException
558 {
559 return sendCommand(command, null);
560 }
561
562
563 /***
564 * Sends an FTP command with no arguments to the server, waits for a
565 * reply and returns the numerical response code. After invocation, for
566 * more detailed information, the actual reply text can be accessed by
567 * calling {@link #getReplyString getReplyString } or
568 * {@link #getReplyStrings getReplyStrings }.
569 * <p>
570 * @param command The FTPCommand constant corresponding to the FTP command
571 * to send.
572 * @return The integer value of the FTP reply code returned by the server
573 * in response to the command.
574 * @exception FTPConnectionClosedException
575 * If the FTP server prematurely closes the connection as a result
576 * of the client being idle or some other reason causing the server
577 * to send FTP reply code 421. This exception may be caught either
578 * as an IOException or independently as itself.
579 * @exception IOException If an I/O error occurs while either sending the
580 * command or receiving the server reply.
581 ***/
582 public int sendCommand(int command) throws IOException
583 {
584 return sendCommand(command, null);
585 }
586
587
588 /***
589 * Returns the integer value of the reply code of the last FTP reply.
590 * You will usually only use this method after you connect to the
591 * FTP server to check that the connection was successful since
592 * <code> connect </code> is of type void.
593 * <p>
594 * @return The integer value of the reply code of the last FTP reply.
595 ***/
596 public int getReplyCode()
597 {
598 return _replyCode;
599 }
600
601 /***
602 * Fetches a reply from the FTP server and returns the integer reply
603 * code. After calling this method, the actual reply text can be accessed
604 * from either calling {@link #getReplyString getReplyString } or
605 * {@link #getReplyStrings getReplyStrings }. Only use this
606 * method if you are implementing your own FTP client or if you need to
607 * fetch a secondary response from the FTP server.
608 * <p>
609 * @return The integer value of the reply code of the fetched FTP reply.
610 * @exception FTPConnectionClosedException
611 * If the FTP server prematurely closes the connection as a result
612 * of the client being idle or some other reason causing the server
613 * to send FTP reply code 421. This exception may be caught either
614 * as an IOException or independently as itself.
615 * @exception IOException If an I/O error occurs while receiving the
616 * server reply.
617 ***/
618 public int getReply() throws IOException
619 {
620 __getReply();
621 return _replyCode;
622 }
623
624
625 /***
626 * Returns the lines of text from the last FTP server response as an array
627 * of strings, one entry per line. The end of line markers of each are
628 * stripped from each line.
629 * <p>
630 * @return The lines of text from the last FTP response as an array.
631 ***/
632 public String[] getReplyStrings()
633 {
634 String[] lines;
635 lines = new String[_replyLines.size()];
636 _replyLines.addAll(Arrays.asList(lines));
637 return lines;
638 }
639
640 /***
641 * Returns the entire text of the last FTP server response exactly
642 * as it was received, including all end of line markers in NETASCII
643 * format.
644 * <p>
645 * @return The entire text from the last FTP response as a String.
646 ***/
647 public String getReplyString()
648 {
649 StringBuilder buffer;
650
651 if (!_newReplyString) {
652 return _replyString;
653 }
654
655 buffer = new StringBuilder(256);
656
657 for (String line : _replyLines) {
658 buffer.append(line);
659 buffer.append(SocketClient.NETASCII_EOL);
660 }
661
662 _newReplyString = false;
663
664 return (_replyString = buffer.toString());
665 }
666
667
668 /***
669 * A convenience method to send the FTP USER command to the server,
670 * receive the reply, and return the reply code.
671 * <p>
672 * @param username The username to login under.
673 * @return The reply code received from the server.
674 * @exception FTPConnectionClosedException
675 * If the FTP server prematurely closes the connection as a result
676 * of the client being idle or some other reason causing the server
677 * to send FTP reply code 421. This exception may be caught either
678 * as an IOException or independently as itself.
679 * @exception IOException If an I/O error occurs while either sending the
680 * command or receiving the server reply.
681 ***/
682 public int user(String username) throws IOException
683 {
684 return sendCommand(FTPCommand.USER, username);
685 }
686
687 /**
688 * A convenience method to send the FTP PASS command to the server,
689 * receive the reply, and return the reply code.
690 * @param password The plain text password of the username being logged into.
691 * @return The reply code received from the server.
692 * @exception FTPConnectionClosedException
693 * If the FTP server prematurely closes the connection as a result
694 * of the client being idle or some other reason causing the server
695 * to send FTP reply code 421. This exception may be caught either
696 * as an IOException or independently as itself.
697 * @exception IOException If an I/O error occurs while either sending the
698 * command or receiving the server reply.
699 */
700 public int pass(String password) throws IOException
701 {
702 return sendCommand(FTPCommand.PASS, password);
703 }
704
705 /***
706 * A convenience method to send the FTP ACCT command to the server,
707 * receive the reply, and return the reply code.
708 * <p>
709 * @param account The account name to access.
710 * @return The reply code received from the server.
711 * @exception FTPConnectionClosedException
712 * If the FTP server prematurely closes the connection as a result
713 * of the client being idle or some other reason causing the server
714 * to send FTP reply code 421. This exception may be caught either
715 * as an IOException or independently as itself.
716 * @exception IOException If an I/O error occurs while either sending the
717 * command or receiving the server reply.
718 ***/
719 public int acct(String account) throws IOException
720 {
721 return sendCommand(FTPCommand.ACCT, account);
722 }
723
724
725 /***
726 * A convenience method to send the FTP ABOR command to the server,
727 * receive the reply, and return the reply code.
728 * <p>
729 * @return The reply code received from the server.
730 * @exception FTPConnectionClosedException
731 * If the FTP server prematurely closes the connection as a result
732 * of the client being idle or some other reason causing the server
733 * to send FTP reply code 421. This exception may be caught either
734 * as an IOException or independently as itself.
735 * @exception IOException If an I/O error occurs while either sending the
736 * command or receiving the server reply.
737 ***/
738 public int abor() throws IOException
739 {
740 return sendCommand(FTPCommand.ABOR);
741 }
742
743 /***
744 * A convenience method to send the FTP CWD command to the server,
745 * receive the reply, and return the reply code.
746 * <p>
747 * @param directory The new working directory.
748 * @return The reply code received from the server.
749 * @exception FTPConnectionClosedException
750 * If the FTP server prematurely closes the connection as a result
751 * of the client being idle or some other reason causing the server
752 * to send FTP reply code 421. This exception may be caught either
753 * as an IOException or independently as itself.
754 * @exception IOException If an I/O error occurs while either sending the
755 * command or receiving the server reply.
756 ***/
757 public int cwd(String directory) throws IOException
758 {
759 return sendCommand(FTPCommand.CWD, directory);
760 }
761
762 /***
763 * A convenience method to send the FTP CDUP command to the server,
764 * receive the reply, and return the reply code.
765 * <p>
766 * @return The reply code received from the server.
767 * @exception FTPConnectionClosedException
768 * If the FTP server prematurely closes the connection as a result
769 * of the client being idle or some other reason causing the server
770 * to send FTP reply code 421. This exception may be caught either
771 * as an IOException or independently as itself.
772 * @exception IOException If an I/O error occurs while either sending the
773 * command or receiving the server reply.
774 ***/
775 public int cdup() throws IOException
776 {
777 return sendCommand(FTPCommand.CDUP);
778 }
779
780 /***
781 * A convenience method to send the FTP QUIT command to the server,
782 * receive the reply, and return the reply code.
783 * <p>
784 * @return The reply code received from the server.
785 * @exception FTPConnectionClosedException
786 * If the FTP server prematurely closes the connection as a result
787 * of the client being idle or some other reason causing the server
788 * to send FTP reply code 421. This exception may be caught either
789 * as an IOException or independently as itself.
790 * @exception IOException If an I/O error occurs while either sending the
791 * command or receiving the server reply.
792 ***/
793 public int quit() throws IOException
794 {
795 return sendCommand(FTPCommand.QUIT);
796 }
797
798 /***
799 * A convenience method to send the FTP REIN command to the server,
800 * receive the reply, and return the reply code.
801 * <p>
802 * @return The reply code received from the server.
803 * @exception FTPConnectionClosedException
804 * If the FTP server prematurely closes the connection as a result
805 * of the client being idle or some other reason causing the server
806 * to send FTP reply code 421. This exception may be caught either
807 * as an IOException or independently as itself.
808 * @exception IOException If an I/O error occurs while either sending the
809 * command or receiving the server reply.
810 ***/
811 public int rein() throws IOException
812 {
813 return sendCommand(FTPCommand.REIN);
814 }
815
816 /***
817 * A convenience method to send the FTP SMNT command to the server,
818 * receive the reply, and return the reply code.
819 * <p>
820 * @param dir The directory name.
821 * @return The reply code received from the server.
822 * @exception FTPConnectionClosedException
823 * If the FTP server prematurely closes the connection as a result
824 * of the client being idle or some other reason causing the server
825 * to send FTP reply code 421. This exception may be caught either
826 * as an IOException or independently as itself.
827 * @exception IOException If an I/O error occurs while either sending the
828 * command or receiving the server reply.
829 ***/
830 public int smnt(String dir) throws IOException
831 {
832 return sendCommand(FTPCommand.SMNT, dir);
833 }
834
835 /***
836 * A convenience method to send the FTP PORT command to the server,
837 * receive the reply, and return the reply code.
838 * <p>
839 * @param host The host owning the port.
840 * @param port The new port.
841 * @return The reply code received from the server.
842 * @exception FTPConnectionClosedException
843 * If the FTP server prematurely closes the connection as a result
844 * of the client being idle or some other reason causing the server
845 * to send FTP reply code 421. This exception may be caught either
846 * as an IOException or independently as itself.
847 * @exception IOException If an I/O error occurs while either sending the
848 * command or receiving the server reply.
849 ***/
850 public int port(InetAddress host, int port) throws IOException
851 {
852 int num;
853 StringBuffer info = new StringBuffer(24);
854
855 info.append(host.getHostAddress().replace('.', ','));
856 num = port >>> 8;
857 info.append(',');
858 info.append(num);
859 info.append(',');
860 num = port & 0xff;
861 info.append(num);
862
863 return sendCommand(FTPCommand.PORT, info.toString());
864 }
865
866 /***
867 * A convenience method to send the FTP PASV command to the server,
868 * receive the reply, and return the reply code. Remember, it's up
869 * to you to interpret the reply string containing the host/port
870 * information.
871 * <p>
872 * @return The reply code received from the server.
873 * @exception FTPConnectionClosedException
874 * If the FTP server prematurely closes the connection as a result
875 * of the client being idle or some other reason causing the server
876 * to send FTP reply code 421. This exception may be caught either
877 * as an IOException or independently as itself.
878 * @exception IOException If an I/O error occurs while either sending the
879 * command or receiving the server reply.
880 ***/
881 public int pasv() throws IOException
882 {
883 return sendCommand(FTPCommand.PASV);
884 }
885
886 /**
887 * A convenience method to send the FTP TYPE command for text files
888 * to the server, receive the reply, and return the reply code.
889 * @param fileType The type of the file (one of the <code>FILE_TYPE</code>
890 * constants).
891 * @param formatOrByteSize The format of the file (one of the
892 * <code>_FORMAT</code> constants. In the case of
893 * <code>LOCAL_FILE_TYPE</code>, the byte size.
894 * @return The reply code received from the server.
895 * @exception FTPConnectionClosedException
896 * If the FTP server prematurely closes the connection as a result
897 * of the client being idle or some other reason causing the server
898 * to send FTP reply code 421. This exception may be caught either
899 * as an IOException or independently as itself.
900 * @exception IOException If an I/O error occurs while either sending the
901 * command or receiving the server reply.
902 */
903 public int type(int fileType, int formatOrByteSize) throws IOException
904 {
905 StringBuffer arg = new StringBuffer();
906
907 arg.append(__modes.charAt(fileType));
908 arg.append(' ');
909 if (fileType == LOCAL_FILE_TYPE)
910 arg.append(formatOrByteSize);
911 else
912 arg.append(__modes.charAt(formatOrByteSize));
913
914 return sendCommand(FTPCommand.TYPE, arg.toString());
915 }
916
917
918 /**
919 * A convenience method to send the FTP TYPE command to the server,
920 * receive the reply, and return the reply code.
921 * <p>
922 * @param fileType The type of the file (one of the <code>FILE_TYPE</code>
923 * constants).
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 type(int fileType) throws IOException
934 {
935 return sendCommand(FTPCommand.TYPE,
936 __modes.substring(fileType, fileType + 1));
937 }
938
939 /***
940 * A convenience method to send the FTP STRU command to the server,
941 * receive the reply, and return the reply code.
942 * <p>
943 * @param structure The structure of the file (one of the
944 * <code>_STRUCTURE</code> constants).
945 * @return The reply code received from the server.
946 * @exception FTPConnectionClosedException
947 * If the FTP server prematurely closes the connection as a result
948 * of the client being idle or some other reason causing the server
949 * to send FTP reply code 421. This exception may be caught either
950 * as an IOException or independently as itself.
951 * @exception IOException If an I/O error occurs while either sending the
952 * command or receiving the server reply.
953 ***/
954 public int stru(int structure) throws IOException
955 {
956 return sendCommand(FTPCommand.STRU,
957 __modes.substring(structure, structure + 1));
958 }
959
960 /***
961 * A convenience method to send the FTP MODE command to the server,
962 * receive the reply, and return the reply code.
963 * <p>
964 * @param mode The transfer mode to use (one of the
965 * <code>TRANSFER_MODE</code> constants).
966 * @return The reply code received from the server.
967 * @exception FTPConnectionClosedException
968 * If the FTP server prematurely closes the connection as a result
969 * of the client being idle or some other reason causing the server
970 * to send FTP reply code 421. This exception may be caught either
971 * as an IOException or independently as itself.
972 * @exception IOException If an I/O error occurs while either sending the
973 * command or receiving the server reply.
974 ***/
975 public int mode(int mode) throws IOException
976 {
977 return sendCommand(FTPCommand.MODE,
978 __modes.substring(mode, mode + 1));
979 }
980
981 /***
982 * A convenience method to send the FTP RETR command to the server,
983 * receive the reply, and return the reply code. Remember, it is up
984 * to you to manage the data connection. If you don't need this low
985 * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
986 * , which will handle all low level details for you.
987 * <p>
988 * @param pathname The pathname of the file to retrieve.
989 * @return The reply code received from the server.
990 * @exception FTPConnectionClosedException
991 * If the FTP server prematurely closes the connection as a result
992 * of the client being idle or some other reason causing the server
993 * to send FTP reply code 421. This exception may be caught either
994 * as an IOException or independently as itself.
995 * @exception IOException If an I/O error occurs while either sending the
996 * command or receiving the server reply.
997 ***/
998 public int retr(String pathname) throws IOException
999 {
1000 return sendCommand(FTPCommand.RETR, pathname);
1001 }
1002
1003 /***
1004 * A convenience method to send the FTP STOR command to the server,
1005 * receive the reply, and return the reply code. Remember, it is up
1006 * to you to manage the data connection. If you don't need this low
1007 * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1008 * , which will handle all low level details for you.
1009 * <p>
1010 * @param pathname The pathname to use for the file when stored at
1011 * the remote end of the transfer.
1012 * @return The reply code received from the server.
1013 * @exception FTPConnectionClosedException
1014 * If the FTP server prematurely closes the connection as a result
1015 * of the client being idle or some other reason causing the server
1016 * to send FTP reply code 421. This exception may be caught either
1017 * as an IOException or independently as itself.
1018 * @exception IOException If an I/O error occurs while either sending the
1019 * command or receiving the server reply.
1020 ***/
1021 public int stor(String pathname) throws IOException
1022 {
1023 return sendCommand(FTPCommand.STOR, pathname);
1024 }
1025
1026 /***
1027 * A convenience method to send the FTP STOU command to the server,
1028 * receive the reply, and return the reply code. Remember, it is up
1029 * to you to manage the data connection. If you don't need this low
1030 * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1031 * , which will handle all low level details for you.
1032 * <p>
1033 * @return The reply code received from the server.
1034 * @exception FTPConnectionClosedException
1035 * If the FTP server prematurely closes the connection as a result
1036 * of the client being idle or some other reason causing the server
1037 * to send FTP reply code 421. This exception may be caught either
1038 * as an IOException or independently as itself.
1039 * @exception IOException If an I/O error occurs while either sending the
1040 * command or receiving the server reply.
1041 ***/
1042 public int stou() throws IOException
1043 {
1044 return sendCommand(FTPCommand.STOU);
1045 }
1046
1047 /***
1048 * A convenience method to send the FTP STOU command to the server,
1049 * receive the reply, and return the reply code. Remember, it is up
1050 * to you to manage the data connection. If you don't need this low
1051 * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1052 * , which will handle all low level details for you.
1053 * @param pathname The base pathname to use for the file when stored at
1054 * the remote end of the transfer. Some FTP servers
1055 * require this.
1056 * @return The reply code received from the server.
1057 * @exception FTPConnectionClosedException
1058 * If the FTP server prematurely closes the connection as a result
1059 * of the client being idle or some other reason causing the server
1060 * to send FTP reply code 421. This exception may be caught either
1061 * as an IOException or independently as itself.
1062 * @exception IOException If an I/O error occurs while either sending the
1063 * command or receiving the server reply.
1064 */
1065 public int stou(String pathname) throws IOException
1066 {
1067 return sendCommand(FTPCommand.STOU, pathname);
1068 }
1069
1070 /***
1071 * A convenience method to send the FTP APPE command to the server,
1072 * receive the reply, and return the reply code. Remember, it is up
1073 * to you to manage the data connection. If you don't need this low
1074 * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1075 * , which will handle all low level details for you.
1076 * <p>
1077 * @param pathname The pathname to use for the file when stored at
1078 * the remote end of the transfer.
1079 * @return The reply code received from the server.
1080 * @exception FTPConnectionClosedException
1081 * If the FTP server prematurely closes the connection as a result
1082 * of the client being idle or some other reason causing the server
1083 * to send FTP reply code 421. This exception may be caught either
1084 * as an IOException or independently as itself.
1085 * @exception IOException If an I/O error occurs while either sending the
1086 * command or receiving the server reply.
1087 ***/
1088 public int appe(String pathname) throws IOException
1089 {
1090 return sendCommand(FTPCommand.APPE, pathname);
1091 }
1092
1093 /***
1094 * A convenience method to send the FTP ALLO command to the server,
1095 * receive the reply, and return the reply code.
1096 * <p>
1097 * @param bytes The number of bytes to allocate.
1098 * @return The reply code received from the server.
1099 * @exception FTPConnectionClosedException
1100 * If the FTP server prematurely closes the connection as a result
1101 * of the client being idle or some other reason causing the server
1102 * to send FTP reply code 421. This exception may be caught either
1103 * as an IOException or independently as itself.
1104 * @exception IOException If an I/O error occurs while either sending the
1105 * command or receiving the server reply.
1106 ***/
1107 public int allo(int bytes) throws IOException
1108 {
1109 return sendCommand(FTPCommand.ALLO, Integer.toString(bytes));
1110 }
1111
1112 /***
1113 * A convenience method to send the FTP ALLO command to the server,
1114 * receive the reply, and return the reply code.
1115 * <p>
1116 * @param bytes The number of bytes to allocate.
1117 * @param recordSize The size of a record.
1118 * @return The reply code received from the server.
1119 * @exception FTPConnectionClosedException
1120 * If the FTP server prematurely closes the connection as a result
1121 * of the client being idle or some other reason causing the server
1122 * to send FTP reply code 421. This exception may be caught either
1123 * as an IOException or independently as itself.
1124 * @exception IOException If an I/O error occurs while either sending the
1125 * command or receiving the server reply.
1126 ***/
1127 public int allo(int bytes, int recordSize) throws IOException
1128 {
1129 return sendCommand(FTPCommand.ALLO, Integer.toString(bytes) + " R " +
1130 Integer.toString(recordSize));
1131 }
1132
1133 /***
1134 * A convenience method to send the FTP REST command to the server,
1135 * receive the reply, and return the reply code.
1136 * <p>
1137 * @param marker The marker at which to restart a transfer.
1138 * @return The reply code received from the server.
1139 * @exception FTPConnectionClosedException
1140 * If the FTP server prematurely closes the connection as a result
1141 * of the client being idle or some other reason causing the server
1142 * to send FTP reply code 421. This exception may be caught either
1143 * as an IOException or independently as itself.
1144 * @exception IOException If an I/O error occurs while either sending the
1145 * command or receiving the server reply.
1146 ***/
1147 public int rest(String marker) throws IOException
1148 {
1149 return sendCommand(FTPCommand.REST, marker);
1150 }
1151
1152
1153 /**
1154 * @since 2.0
1155 **/
1156 public int mdtm(String file) throws IOException
1157 {
1158 return sendCommand(FTPCommand.MDTM, file);
1159 }
1160
1161 /***
1162 * A convenience method to send the FTP RNFR command to the server,
1163 * receive the reply, and return the reply code.
1164 * <p>
1165 * @param pathname The pathname to rename from.
1166 * @return The reply code received from the server.
1167 * @exception FTPConnectionClosedException
1168 * If the FTP server prematurely closes the connection as a result
1169 * of the client being idle or some other reason causing the server
1170 * to send FTP reply code 421. This exception may be caught either
1171 * as an IOException or independently as itself.
1172 * @exception IOException If an I/O error occurs while either sending the
1173 * command or receiving the server reply.
1174 ***/
1175 public int rnfr(String pathname) throws IOException
1176 {
1177 return sendCommand(FTPCommand.RNFR, pathname);
1178 }
1179
1180 /***
1181 * A convenience method to send the FTP RNTO command to the server,
1182 * receive the reply, and return the reply code.
1183 * <p>
1184 * @param pathname The pathname to rename to
1185 * @return The reply code received from the server.
1186 * @exception FTPConnectionClosedException
1187 * If the FTP server prematurely closes the connection as a result
1188 * of the client being idle or some other reason causing the server
1189 * to send FTP reply code 421. This exception may be caught either
1190 * as an IOException or independently as itself.
1191 * @exception IOException If an I/O error occurs while either sending the
1192 * command or receiving the server reply.
1193 ***/
1194 public int rnto(String pathname) throws IOException
1195 {
1196 return sendCommand(FTPCommand.RNTO, pathname);
1197 }
1198
1199 /***
1200 * A convenience method to send the FTP DELE command to the server,
1201 * receive the reply, and return the reply code.
1202 * <p>
1203 * @param pathname The pathname to delete.
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 dele(String pathname) throws IOException
1214 {
1215 return sendCommand(FTPCommand.DELE, pathname);
1216 }
1217
1218 /***
1219 * A convenience method to send the FTP RMD command to the server,
1220 * receive the reply, and return the reply code.
1221 * <p>
1222 * @param pathname The pathname of the directory to remove.
1223 * @return The reply code received from the server.
1224 * @exception FTPConnectionClosedException
1225 * If the FTP server prematurely closes the connection as a result
1226 * of the client being idle or some other reason causing the server
1227 * to send FTP reply code 421. This exception may be caught either
1228 * as an IOException or independently as itself.
1229 * @exception IOException If an I/O error occurs while either sending the
1230 * command or receiving the server reply.
1231 ***/
1232 public int rmd(String pathname) throws IOException
1233 {
1234 return sendCommand(FTPCommand.RMD, pathname);
1235 }
1236
1237 /***
1238 * A convenience method to send the FTP MKD command to the server,
1239 * receive the reply, and return the reply code.
1240 * <p>
1241 * @param pathname The pathname of the new directory to create.
1242 * @return The reply code received from the server.
1243 * @exception FTPConnectionClosedException
1244 * If the FTP server prematurely closes the connection as a result
1245 * of the client being idle or some other reason causing the server
1246 * to send FTP reply code 421. This exception may be caught either
1247 * as an IOException or independently as itself.
1248 * @exception IOException If an I/O error occurs while either sending the
1249 * command or receiving the server reply.
1250 ***/
1251 public int mkd(String pathname) throws IOException
1252 {
1253 return sendCommand(FTPCommand.MKD, pathname);
1254 }
1255
1256 /***
1257 * A convenience method to send the FTP PWD command to the server,
1258 * receive the reply, and return the reply code.
1259 * <p>
1260 * @return The reply code received from the server.
1261 * @exception FTPConnectionClosedException
1262 * If the FTP server prematurely closes the connection as a result
1263 * of the client being idle or some other reason causing the server
1264 * to send FTP reply code 421. This exception may be caught either
1265 * as an IOException or independently as itself.
1266 * @exception IOException If an I/O error occurs while either sending the
1267 * command or receiving the server reply.
1268 ***/
1269 public int pwd() throws IOException
1270 {
1271 return sendCommand(FTPCommand.PWD);
1272 }
1273
1274 /***
1275 * A convenience method to send the FTP LIST command to the server,
1276 * receive the reply, and return the reply code. Remember, it is up
1277 * to you to manage the data connection. If you don't need this low
1278 * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1279 * , which will handle all low level details for you.
1280 * <p>
1281 * @return The reply code received from the server.
1282 * @exception FTPConnectionClosedException
1283 * If the FTP server prematurely closes the connection as a result
1284 * of the client being idle or some other reason causing the server
1285 * to send FTP reply code 421. This exception may be caught either
1286 * as an IOException or independently as itself.
1287 * @exception IOException If an I/O error occurs while either sending the
1288 * command or receiving the server reply.
1289 ***/
1290 public int list() throws IOException
1291 {
1292 return sendCommand(FTPCommand.LIST);
1293 }
1294
1295 /***
1296 * A convenience method to send the FTP LIST command to the server,
1297 * receive the reply, and return the reply code. Remember, it is up
1298 * to you to manage the data connection. If you don't need this low
1299 * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1300 * , which will handle all low level details for you.
1301 * <p>
1302 * @param pathname The pathname to list.
1303 * @return The reply code received from the server.
1304 * @exception FTPConnectionClosedException
1305 * If the FTP server prematurely closes the connection as a result
1306 * of the client being idle or some other reason causing the server
1307 * to send FTP reply code 421. This exception may be caught either
1308 * as an IOException or independently as itself.
1309 * @exception IOException If an I/O error occurs while either sending the
1310 * command or receiving the server reply.
1311 ***/
1312 public int list(String pathname) throws IOException
1313 {
1314 return sendCommand(FTPCommand.LIST, pathname);
1315 }
1316
1317 /***
1318 * A convenience method to send the FTP NLST command to the server,
1319 * receive the reply, and return the reply code. Remember, it is up
1320 * to you to manage the data connection. If you don't need this low
1321 * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1322 * , which will handle all low level details for you.
1323 * <p>
1324 * @return The reply code received from the server.
1325 * @exception FTPConnectionClosedException
1326 * If the FTP server prematurely closes the connection as a result
1327 * of the client being idle or some other reason causing the server
1328 * to send FTP reply code 421. This exception may be caught either
1329 * as an IOException or independently as itself.
1330 * @exception IOException If an I/O error occurs while either sending the
1331 * command or receiving the server reply.
1332 ***/
1333 public int nlst() throws IOException
1334 {
1335 return sendCommand(FTPCommand.NLST);
1336 }
1337
1338 /***
1339 * A convenience method to send the FTP NLST command to the server,
1340 * receive the reply, and return the reply code. Remember, it is up
1341 * to you to manage the data connection. If you don't need this low
1342 * level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1343 * , which will handle all low level details for you.
1344 * <p>
1345 * @param pathname The pathname to list.
1346 * @return The reply code received from the server.
1347 * @exception FTPConnectionClosedException
1348 * If the FTP server prematurely closes the connection as a result
1349 * of the client being idle or some other reason causing the server
1350 * to send FTP reply code 421. This exception may be caught either
1351 * as an IOException or independently as itself.
1352 * @exception IOException If an I/O error occurs while either sending the
1353 * command or receiving the server reply.
1354 ***/
1355 public int nlst(String pathname) throws IOException
1356 {
1357 return sendCommand(FTPCommand.NLST, pathname);
1358 }
1359
1360 /***
1361 * A convenience method to send the FTP SITE command to the server,
1362 * receive the reply, and return the reply code.
1363 * <p>
1364 * @param parameters The site parameters to send.
1365 * @return The reply code received from the server.
1366 * @exception FTPConnectionClosedException
1367 * If the FTP server prematurely closes the connection as a result
1368 * of the client being idle or some other reason causing the server
1369 * to send FTP reply code 421. This exception may be caught either
1370 * as an IOException or independently as itself.
1371 * @exception IOException If an I/O error occurs while either sending the
1372 * command or receiving the server reply.
1373 ***/
1374 public int site(String parameters) throws IOException
1375 {
1376 return sendCommand(FTPCommand.SITE, parameters);
1377 }
1378
1379 /***
1380 * A convenience method to send the FTP SYST command to the server,
1381 * receive the reply, and return the reply code.
1382 * <p>
1383 * @return The reply code received from the server.
1384 * @exception FTPConnectionClosedException
1385 * If the FTP server prematurely closes the connection as a result
1386 * of the client being idle or some other reason causing the server
1387 * to send FTP reply code 421. This exception may be caught either
1388 * as an IOException or independently as itself.
1389 * @exception IOException If an I/O error occurs while either sending the
1390 * command or receiving the server reply.
1391 ***/
1392 public int syst() throws IOException
1393 {
1394 return sendCommand(FTPCommand.SYST);
1395 }
1396
1397 /***
1398 * A convenience method to send the FTP STAT command to the server,
1399 * receive the reply, and return the reply code.
1400 * <p>
1401 * @return The reply code received from the server.
1402 * @exception FTPConnectionClosedException
1403 * If the FTP server prematurely closes the connection as a result
1404 * of the client being idle or some other reason causing the server
1405 * to send FTP reply code 421. This exception may be caught either
1406 * as an IOException or independently as itself.
1407 * @exception IOException If an I/O error occurs while either sending the
1408 * command or receiving the server reply.
1409 ***/
1410 public int stat() throws IOException
1411 {
1412 return sendCommand(FTPCommand.STAT);
1413 }
1414
1415 /***
1416 * A convenience method to send the FTP STAT command to the server,
1417 * receive the reply, and return the reply code.
1418 * <p>
1419 * @param pathname A pathname to list.
1420 * @return The reply code received from the server.
1421 * @exception FTPConnectionClosedException
1422 * If the FTP server prematurely closes the connection as a result
1423 * of the client being idle or some other reason causing the server
1424 * to send FTP reply code 421. This exception may be caught either
1425 * as an IOException or independently as itself.
1426 * @exception IOException If an I/O error occurs while either sending the
1427 * command or receiving the server reply.
1428 ***/
1429 public int stat(String pathname) throws IOException
1430 {
1431 return sendCommand(FTPCommand.STAT, pathname);
1432 }
1433
1434 /***
1435 * A convenience method to send the FTP HELP command to the server,
1436 * receive the reply, and return the reply code.
1437 * <p>
1438 * @return The reply code received from the server.
1439 * @exception FTPConnectionClosedException
1440 * If the FTP server prematurely closes the connection as a result
1441 * of the client being idle or some other reason causing the server
1442 * to send FTP reply code 421. This exception may be caught either
1443 * as an IOException or independently as itself.
1444 * @exception IOException If an I/O error occurs while either sending the
1445 * command or receiving the server reply.
1446 ***/
1447 public int help() throws IOException
1448 {
1449 return sendCommand(FTPCommand.HELP);
1450 }
1451
1452 /***
1453 * A convenience method to send the FTP HELP command to the server,
1454 * receive the reply, and return the reply code.
1455 * <p>
1456 * @param command The command name on which to request help.
1457 * @return The reply code received from the server.
1458 * @exception FTPConnectionClosedException
1459 * If the FTP server prematurely closes the connection as a result
1460 * of the client being idle or some other reason causing the server
1461 * to send FTP reply code 421. This exception may be caught either
1462 * as an IOException or independently as itself.
1463 * @exception IOException If an I/O error occurs while either sending the
1464 * command or receiving the server reply.
1465 ***/
1466 public int help(String command) throws IOException
1467 {
1468 return sendCommand(FTPCommand.HELP, command);
1469 }
1470
1471 /***
1472 * A convenience method to send the FTP NOOP command to the server,
1473 * receive the reply, and return the reply code.
1474 * <p>
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 noop() throws IOException
1485 {
1486 return sendCommand(FTPCommand.NOOP);
1487 }
1488
1489 /**
1490 * Return whether strict multiline parsing is enabled, as per RFX 959, section 4.2.
1491 * @return True if strict, false if lenient
1492 * @since 2.0
1493 */
1494 public boolean isStrictMultilineParsing() {
1495 return strictMultilineParsing;
1496 }
1497
1498 /**
1499 * Set strict multiline parsing.
1500 * @param strictMultilineParsing
1501 * @since 2.0
1502 */
1503 public void setStrictMultilineParsing(boolean strictMultilineParsing) {
1504 this.strictMultilineParsing = strictMultilineParsing;
1505 }
1506 }
1507
1508 /* Emacs configuration
1509 * Local variables: **
1510 * mode: java **
1511 * c-basic-offset: 4 **
1512 * indent-tabs-mode: nil **
1513 * End: **
1514 */