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

This page was automatically generated by Maven