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 */