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