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.BufferedInputStream; 58 import java.io.BufferedOutputStream; 59 import java.io.BufferedReader; 60 import java.io.IOException; 61 import java.io.InputStream; 62 import java.io.InputStreamReader; 63 import java.io.OutputStream; 64 import java.net.InetAddress; 65 import java.net.ServerSocket; 66 import java.net.Socket; 67 import java.util.Vector; 68 import org.apache.commons.net.io.FromNetASCIIInputStream; 69 import org.apache.commons.net.io.ToNetASCIIOutputStream; 70 import org.apache.commons.net.io.Util; 71 import org.apache.commons.net.MalformedServerReplyException; 72 73 /**** 74 * FTPClient encapsulates all the functionality necessary to store and 75 * retrieve files from an FTP server. This class takes care of all 76 * low level details of interacting with an FTP server and provides 77 * a convenient higher level interface. As with all classes derived 78 * from <a href="org.apache.commons.net.SocketClient.html"> SocketClient </a>, 79 * you must first connect to the server with 80 * <a href="org.apache.commons.net.SocketClient.html#connect"> connect </a> 81 * before doing anything, and finally 82 * <a href="org.apache.commons.net.SocketClient.html#disconnect"> disconnect </a> 83 * after you're completely finished interacting with the server. 84 * Then you need to check the FTP reply code to see if the connection 85 * was successful. For example: 86 * <pre> 87 * try { 88 * int reply; 89 * ftp.connect("ftp.foobar.com"); 90 * System.out.println("Connected to " + server + "."); 91 * System.out.print(ftp.getReplyString()); 92 * 93 * // After connection attempt, you should check the reply code to verify 94 * // success. 95 * reply = ftp.getReplyCode(); 96 * 97 * if(!FTPReply.isPositiveCompletion(reply)) { 98 * ftp.disconnect(); 99 * System.err.println("FTP server refused connection."); 100 * System.exit(1); 101 * } 102 * } catch(IOException e) { 103 * if(ftp.isConnected()) { 104 * try { 105 * ftp.disconnect(); 106 * } catch(IOException f) { 107 * // do nothing 108 * } 109 * } 110 * System.err.println("Could not connect to server."); 111 * e.printStackTrace(); 112 * System.exit(1); 113 * } 114 * </pre> 115 * <p> 116 * Immediately after connecting is the only real time you need to check the 117 * reply code (because connect is of type void). The convention for all the 118 * FTP command methods in FTPClient is such that they either return a 119 * boolean value or some other value. 120 * The boolean methods return true on a successful completion reply from 121 * the FTP server and false on a reply resulting in an error condition or 122 * failure. The methods returning a value other than boolean return a value 123 * containing the higher level data produced by the FTP command, or null if a 124 * reply resulted in an error condition or failure. If you want to access 125 * the exact FTP reply code causing a success or failure, you must call 126 * <a href="org.apache.commons.net.ftp.FTP.html#getReplyCode"> getReplyCode </a> after 127 * a success or failure. 128 * <p> 129 * The default settings for FTPClient are for it to use 130 * <code> FTP.ASCII_FILE_TYPE </code>, 131 * <code> FTP.NON_PRINT_TEXT_FORMAT </code>, 132 * <code> FTP.STREAM_TRANSFER_MODE </code>, and 133 * <code> FTP.FILE_STRUCTURE </code>. The only file types directly supported 134 * are <code> FTP.ASCII_FILE_TYPE </code> and 135 * <code> FTP.IMAGE_FILE_TYPE </code> (which is the same as 136 * <code> FTP.BINARY_FILE_TYPE </code>). Because there are at lest 4 137 * different EBCDIC encodings, we have opted not to provide direct support 138 * for EBCDIC. To transfer EBCDIC and other unsupported file types you 139 * must create your own filter InputStreams and OutputStreams and wrap 140 * them around the streams returned or required by the FTPClient methods. 141 * FTPClient uses the NetASCII filter streams in 142 * <a href="Package-org.apache.commons.net.io.html"> org.apache.commons.net.io </a> to provide 143 * transparent handling of ASCII files. We will consider incorporating 144 * EBCDIC support if there is enough demand. 145 * <p> 146 * <code> FTP.NON_PRINT_TEXT_FORMAT </code>, 147 * <code> FTP.STREAM_TRANSFER_MODE </code>, and 148 * <code> FTP.FILE_STRUCTURE </code> are the only supported formats, 149 * transfer modes, and file structures. 150 * <p> 151 * Because the handling of sockets on different platforms can differ 152 * significantly, the FTPClient automatically issues a new PORT command 153 * prior to every transfer requiring that the server connect to the client's 154 * data port. This ensures identical problem-free behavior on Windows, Unix, 155 * and Macintosh platforms. Additionally, it relieves programmers from 156 * having to issue the PORT command themselves and dealing with platform 157 * dependent issues. 158 * <p> 159 * Additionally, for security purposes, all data connections to the 160 * client are verified to ensure that they originated from the intended 161 * party (host and port). If a data connection is initiated by an unexpected 162 * party, the command will close the socket and throw an IOException. You 163 * may disable this behavior with 164 * <a href="#setRemoteVerificationEnabled">setRemoteVerificationEnabled()</a>. 165 * <p> 166 * You should keep in mind that the FTP server may choose to prematurely 167 * close a connection if the client has been idle for longer than a 168 * given time period (usually 900 seconds). The FTPClient class will detect a 169 * premature FTP server connection closing when it receives a 170 * <a href="org.apache.commons.net.ftp.FTPReply.html#SERVICE_NOT_AVAILABLE"> 171 * FTPReply.SERVICE_NOT_AVAILABLE </a> response to a command. 172 * When that occurs, the FTP class method encountering that reply will throw 173 * an <a href="org.apache.commons.net.ftp.FTPConnectionClosedException.html"> 174 * FTPConnectionClosedException </a>. 175 * <code>FTPConnectionClosedException</code> 176 * is a subclass of <code> IOException </code> and therefore need not be 177 * caught separately, but if you are going to catch it separately, its 178 * catch block must appear before the more general <code> IOException </code> 179 * catch block. When you encounter an 180 * <a href="org.apache.commons.net.ftp.FTPConnectionClosedException.html"> 181 * FTPConnectionClosedException </a>, you must disconnect the connection with 182 * <a href="#disconnect"> disconnect() </a> to properly clean up the 183 * system resources used by FTPClient. Before disconnecting, you may check the 184 * last reply code and text with 185 * <a href="org.apache.commons.net.ftp.FTP.html#getReplyCode"> getReplyCode </a>, 186 * <a href="org.apache.commons.net.ftp.FTP.html#getReplyString"> getReplyString </a>, 187 * and 188 * <a href="org.apache.commons.net.ftp.FTP.html#getReplyStrings"> getReplyStrings</a>. 189 * You may avoid server disconnections while the client is idle by 190 * periodicaly sending NOOP commands to the server. 191 * <p> 192 * Rather than list it separately for each method, we mention here that 193 * every method communicating with the server and throwing an IOException 194 * can also throw a 195 * <a href="org.apache.commons.net.MalformedServerReplyException.html"> 196 * MalformedServerReplyException </a>, which is a subclass 197 * of IOException. A MalformedServerReplyException will be thrown when 198 * the reply received from the server deviates enough from the protocol 199 * specification that it cannot be interpreted in a useful manner despite 200 * attempts to be as lenient as possible. 201 * <p> 202 * <p> 203 * @author Daniel F. Savarese 204 * @see FTP 205 * @see FTPConnectionClosedException 206 * @see DefaultFTPFileListParser 207 * @see org.apache.commons.net.MalformedServerReplyException 208 ***/ 209 210 public class FTPClient extends FTP 211 { 212 /**** 213 * A constant indicating the FTP session is expecting all transfers 214 * to occur between the client (local) and server and that the server 215 * should connect to the client's data port to initiate a data transfer. 216 * This is the default data connection mode when and FTPClient instance 217 * is created. 218 ***/ 219 public static final int ACTIVE_LOCAL_DATA_CONNECTION_MODE = 0; 220 /**** 221 * A constant indicating the FTP session is expecting all transfers 222 * to occur between two remote servers and that the server 223 * the client is connected to should connect to the other server's 224 * data port to initiate a data transfer. 225 ***/ 226 public static final int ACTIVE_REMOTE_DATA_CONNECTION_MODE = 1; 227 /**** 228 * A constant indicating the FTP session is expecting all transfers 229 * to occur between the client (local) and server and that the server 230 * is in passive mode, requiring the client to connect to the 231 * server's data port to initiate a transfer. 232 ***/ 233 public static final int PASSIVE_LOCAL_DATA_CONNECTION_MODE = 2; 234 /**** 235 * A constant indicating the FTP session is expecting all transfers 236 * to occur between two remote servers and that the server 237 * the client is connected to is in passive mode, requiring the other 238 * server to connect to the first server's data port to initiate a data 239 * transfer. 240 ***/ 241 public static final int PASSIVE_REMOTE_DATA_CONNECTION_MODE = 3; 242 243 private int __dataConnectionMode, __dataTimeout; 244 private int __passivePort; 245 private String __passiveHost; 246 private int __fileType, __fileFormat, __fileStructure, __fileTransferMode; 247 private boolean __remoteVerificationEnabled; 248 private FTPFileListParser __fileListParser; 249 private long __restartOffset; 250 251 /**** 252 * Default FTPClient constructor. Creates a new FTPClient instance 253 * with the data connection mode set to 254 * <code> ACTIVE_LOCAL_DATA_CONNECTION_MODE </code>, the file type 255 * set to <code> FTP.ASCII_FILE_TYPE </code>, the 256 * file format set to <code> FTP.NON_PRINT_TEXT_FORMAT </code>, 257 * the file structure set to <code> FTP.FILE_STRUCTURE </code>, and 258 * the transfer mode set to <code> FTP.STREAM_TRANSFER_MODE </code>. 259 ***/ 260 public FTPClient() 261 { 262 __initDefaults(); 263 __fileListParser = new DefaultFTPFileListParser(); 264 __dataTimeout = -1; 265 __remoteVerificationEnabled = true; 266 } 267 268 269 private void __initDefaults() 270 { 271 __dataConnectionMode = ACTIVE_LOCAL_DATA_CONNECTION_MODE; 272 __passiveHost = null; 273 __passivePort = -1; 274 __fileType = FTP.ASCII_FILE_TYPE; 275 __fileStructure = FTP.FILE_STRUCTURE; 276 __fileFormat = FTP.NON_PRINT_TEXT_FORMAT; 277 __fileTransferMode = FTP.STREAM_TRANSFER_MODE; 278 } 279 280 private String __parsePathname(String reply) 281 { 282 int begin, end; 283 284 begin = reply.indexOf('"') + 1; 285 end = reply.indexOf('"', begin); 286 287 return reply.substring(begin, end); 288 } 289 290 291 private void __parsePassiveModeReply(String reply) 292 throws MalformedServerReplyException 293 { 294 int i, index, lastIndex; 295 String octet1, octet2; 296 StringBuffer host; 297 298 reply = reply.substring(reply.indexOf('(') + 1, 299 reply.indexOf(')')).trim(); 300 301 host = new StringBuffer(24); 302 lastIndex = 0; 303 index = reply.indexOf(','); 304 host.append(reply.substring(lastIndex, index)); 305 306 for (i = 0; i < 3; i++) 307 { 308 host.append('.'); 309 lastIndex = index + 1; 310 index = reply.indexOf(',', lastIndex); 311 host.append(reply.substring(lastIndex, index)); 312 } 313 314 lastIndex = index + 1; 315 index = reply.indexOf(',', lastIndex); 316 317 octet1 = reply.substring(lastIndex, index); 318 octet2 = reply.substring(index + 1); 319 320 // index and lastIndex now used as temporaries 321 try 322 { 323 index = Integer.parseInt(octet1); 324 lastIndex = Integer.parseInt(octet2); 325 } 326 catch (NumberFormatException e) 327 { 328 throw new MalformedServerReplyException( 329 "Could not parse passive host information.\nServer Reply: " + reply); 330 } 331 332 index <<= 8; 333 index |= lastIndex; 334 335 __passiveHost = host.toString(); 336 __passivePort = index; 337 } 338 339 340 // null arg if no arg 341 protected Socket __openDataConnection(int command, String arg) 342 throws IOException 343 { 344 Socket socket; 345 346 if (__dataConnectionMode != ACTIVE_LOCAL_DATA_CONNECTION_MODE && 347 __dataConnectionMode != PASSIVE_LOCAL_DATA_CONNECTION_MODE) 348 return null; 349 350 if (__dataConnectionMode == ACTIVE_LOCAL_DATA_CONNECTION_MODE) 351 { 352 ServerSocket server; 353 server = _socketFactory_.createServerSocket(0, 1, getLocalAddress()); 354 355 if (!FTPReply.isPositiveCompletion(port(getLocalAddress(), 356 server.getLocalPort()))) 357 { 358 server.close(); 359 return null; 360 } 361 362 if ((__restartOffset > 0) && !restart(__restartOffset)) 363 { 364 server.close(); 365 return null; 366 } 367 368 if (!FTPReply.isPositivePreliminary(sendCommand(command, arg))) 369 { 370 server.close(); 371 return null; 372 } 373 374 // For now, let's just use the data timeout value for waiting for 375 // the data connection. It may be desirable to let this be a 376 // separately configurable value. In any case, we really want 377 // to allow preventing the accept from blocking indefinitely. 378 if (__dataTimeout >= 0) 379 server.setSoTimeout(__dataTimeout); 380 socket = server.accept(); 381 server.close(); 382 } 383 else 384 { // We must be in PASSIVE_LOCAL_DATA_CONNECTION_MODE 385 386 if (pasv() != FTPReply.ENTERING_PASSIVE_MODE) 387 return null; 388 389 __parsePassiveModeReply((String)_replyLines.elementAt(0)); 390 391 socket = _socketFactory_.createSocket(__passiveHost, __passivePort); 392 393 if (!FTPReply.isPositivePreliminary(sendCommand(command, arg))) 394 { 395 socket.close(); 396 return null; 397 } 398 } 399 400 if (__remoteVerificationEnabled && !verifyRemote(socket)) 401 { 402 InetAddress host1, host2; 403 404 host1 = socket.getInetAddress(); 405 host2 = getRemoteAddress(); 406 407 socket.close(); 408 409 throw new IOException( 410 "Host attempting data connection " + host1.getHostAddress() + 411 " is not same as server " + host2.getHostAddress()); 412 } 413 414 if (__dataTimeout >= 0) 415 socket.setSoTimeout(__dataTimeout); 416 417 return socket; 418 } 419 420 421 private boolean __storeFile(int command, String remote, InputStream local) 422 throws IOException 423 { 424 OutputStream output; 425 Socket socket; 426 427 if ((socket = __openDataConnection(command, remote)) == null) 428 return false; 429 430 output = new BufferedOutputStream(socket.getOutputStream()); 431 if (__fileType == ASCII_FILE_TYPE) 432 output = new ToNetASCIIOutputStream(output); 433 // Treat everything else as binary for now 434 try 435 { 436 Util.copyStream(local, output); 437 } 438 catch (IOException e) 439 { 440 try 441 { 442 socket.close(); 443 } 444 catch (IOException f) 445 {} 446 throw e; 447 } 448 output.close(); 449 socket.close(); 450 return completePendingCommand(); 451 } 452 453 private OutputStream __storeFileStream(int command, String remote) 454 throws IOException 455 { 456 OutputStream output; 457 Socket socket; 458 459 if ((socket = __openDataConnection(command, remote)) == null) 460 return null; 461 462 output = socket.getOutputStream(); 463 if (__fileType == ASCII_FILE_TYPE) 464 output = new ToNetASCIIOutputStream(output); 465 return new org.apache.commons.net.io.SocketOutputStream(socket, output); 466 } 467 468 469 protected void _connectAction_() throws IOException 470 { 471 super._connectAction_(); 472 __initDefaults(); 473 } 474 475 476 /**** 477 * Sets the timeout in milliseconds to use when reading from the 478 * data connection. This timeout will be set immediately after 479 * opening the data connection. 480 * <p> 481 * @param timeout The default timeout in milliseconds that is used when 482 * opening a data connection socket. 483 ***/ 484 public void setDataTimeout(int timeout) 485 { 486 __dataTimeout = timeout; 487 } 488 489 490 /**** 491 * Closes the connection to the FTP server and restores 492 * connection parameters to the default values. 493 * <p> 494 * @exception IOException If an error occurs while disconnecting. 495 ***/ 496 public void disconnect() throws IOException 497 { 498 super.disconnect(); 499 __initDefaults(); 500 } 501 502 503 /**** 504 * Enable or disable verification that the remote host taking part 505 * of a data connection is the same as the host to which the control 506 * connection is attached. The default is for verification to be 507 * enabled. You may set this value at any time, whether the 508 * FTPClient is currently connected or not. 509 * <p> 510 * @param enable True to enable verification, false to disable verification. 511 ***/ 512 public void setRemoteVerificationEnabled(boolean enable) 513 { 514 __remoteVerificationEnabled = enable; 515 } 516 517 /**** 518 * Return whether or not verification of the remote host participating 519 * in data connections is enabled. The default behavior is for 520 * verification to be enabled. 521 * <p> 522 * @return True if verification is enabled, false if not. 523 ***/ 524 public boolean isRemoteVerificationEnabled() 525 { 526 return __remoteVerificationEnabled; 527 } 528 529 /**** 530 * Login to the FTP server using the provided username and password. 531 * <p> 532 * @param username The username to login under. 533 * @param password The password to use. 534 * @return True if successfully completed, false if not. 535 * @exception FTPConnectionClosedException 536 * If the FTP server prematurely closes the connection as a result 537 * of the client being idle or some other reason causing the server 538 * to send FTP reply code 421. This exception may be caught either 539 * as an IOException or independently as itself. 540 * @exception IOException If an I/O error occurs while either sending a 541 * command to the server or receiving a reply from the server. 542 ***/ 543 public boolean login(String username, String password) throws IOException 544 { 545 user(username); 546 547 if (FTPReply.isPositiveCompletion(_replyCode)) 548 return true; 549 550 // If we get here, we either have an error code, or an intermmediate 551 // reply requesting password. 552 if (!FTPReply.isPositiveIntermediate(_replyCode)) 553 return false; 554 555 return FTPReply.isPositiveCompletion(pass(password)); 556 } 557 558 559 /**** 560 * Login to the FTP server using the provided username, password, 561 * and account. If no account is required by the server, only 562 * the username and password, the account information is not used. 563 * <p> 564 * @param username The username to login under. 565 * @param password The password to use. 566 * @param account The account to use. 567 * @return True if successfully completed, false if not. 568 * @exception FTPConnectionClosedException 569 * If the FTP server prematurely closes the connection as a result 570 * of the client being idle or some other reason causing the server 571 * to send FTP reply code 421. This exception may be caught either 572 * as an IOException or independently as itself. 573 * @exception IOException If an I/O error occurs while either sending a 574 * command to the server or receiving a reply from the server. 575 ***/ 576 public boolean login(String username, String password, String account) 577 throws IOException 578 { 579 user(username); 580 581 if (FTPReply.isPositiveCompletion(_replyCode)) 582 return true; 583 584 // If we get here, we either have an error code, or an intermmediate 585 // reply requesting password. 586 if (!FTPReply.isPositiveIntermediate(_replyCode)) 587 return false; 588 589 pass(password); 590 591 if (FTPReply.isPositiveCompletion(_replyCode)) 592 return true; 593 594 if (!FTPReply.isPositiveIntermediate(_replyCode)) 595 return false; 596 597 return FTPReply.isPositiveCompletion(acct(account)); 598 } 599 600 /**** 601 * Logout of the FTP server by sending the QUIT command. 602 * <p> 603 * @return True if successfully completed, false if not. 604 * @exception FTPConnectionClosedException 605 * If the FTP server prematurely closes the connection as a result 606 * of the client being idle or some other reason causing the server 607 * to send FTP reply code 421. This exception may be caught either 608 * as an IOException or independently as itself. 609 * @exception IOException If an I/O error occurs while either sending a 610 * command to the server or receiving a reply from the server. 611 ***/ 612 public boolean logout() throws IOException 613 { 614 return FTPReply.isPositiveCompletion(quit()); 615 } 616 617 618 /**** 619 * Change the current working directory of the FTP session. 620 * <p> 621 * @param pathname The new current working directory. 622 * @return True if successfully completed, false if not. 623 * @exception FTPConnectionClosedException 624 * If the FTP server prematurely closes the connection as a result 625 * of the client being idle or some other reason causing the server 626 * to send FTP reply code 421. This exception may be caught either 627 * as an IOException or independently as itself. 628 * @exception IOException If an I/O error occurs while either sending a 629 * command to the server or receiving a reply from the server. 630 ***/ 631 public boolean changeWorkingDirectory(String pathname) throws IOException 632 { 633 return FTPReply.isPositiveCompletion(cwd(pathname)); 634 } 635 636 637 /**** 638 * Change to the parent directory of the current working directory. 639 * <p> 640 * @return True if successfully completed, false if not. 641 * @exception FTPConnectionClosedException 642 * If the FTP server prematurely closes the connection as a result 643 * of the client being idle or some other reason causing the server 644 * to send FTP reply code 421. This exception may be caught either 645 * as an IOException or independently as itself. 646 * @exception IOException If an I/O error occurs while either sending a 647 * command to the server or receiving a reply from the server. 648 ***/ 649 public boolean changeToParentDirectory() throws IOException 650 { 651 return FTPReply.isPositiveCompletion(cdup()); 652 } 653 654 655 /**** 656 * Issue the FTP SMNT command. 657 * <p> 658 * @param pathname The pathname to mount. 659 * @return True if successfully completed, false if not. 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 a 666 * command to the server or receiving a reply from the server. 667 ***/ 668 public boolean structureMount(String pathname) throws IOException 669 { 670 return FTPReply.isPositiveCompletion(smnt(pathname)); 671 } 672 673 /**** 674 * Reinitialize the FTP session. Not all FTP servers support this 675 * command, which issues the FTP REIN command. 676 * <p> 677 * @return True if successfully completed, false if not. 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 a 684 * command to the server or receiving a reply from the server. 685 ***/ 686 boolean reinitialize() throws IOException 687 { 688 rein(); 689 690 if (FTPReply.isPositiveCompletion(_replyCode) || 691 (FTPReply.isPositivePreliminary(_replyCode) && 692 FTPReply.isPositiveCompletion(getReply()))) 693 { 694 695 __initDefaults(); 696 697 return true; 698 } 699 700 return false; 701 } 702 703 704 /**** 705 * Set the current data connection mode to 706 * <code>ACTIVE_LOCAL_DATA_CONNECTION_MODE</code>. No communication 707 * with the FTP server is conducted, but this causes all future data 708 * transfers to require the FTP server to connect to the client's 709 * data port. Additionally, to accommodate differences between socket 710 * implementations on different platforms, this method causes the 711 * client to issue a PORT command before every data transfer. 712 ***/ 713 public void enterLocalActiveMode() 714 { 715 __dataConnectionMode = ACTIVE_LOCAL_DATA_CONNECTION_MODE; 716 __passiveHost = null; 717 __passivePort = -1; 718 } 719 720 721 /**** 722 * Set the current data connection mode to 723 * <code> PASSIVE_LOCAL_DATA_CONNECTION_MODE </code>. Use this 724 * method only for data transfers between the client and server. 725 * This method causes a PASV command to be issued to the server 726 * before the opening of every data connection, telling the server to 727 * open a data port to which the client will connect to conduct 728 * data transfers. The FTPClient will stay in 729 * <code> PASSIVE_LOCAL_DATA_CONNECTION_MODE </code> until the 730 * mode is changed by calling some other method such as 731 * <a href="#enterLocalActiveMode"> enterLocalActiveMode() </a> 732 ***/ 733 public void enterLocalPassiveMode() 734 { 735 __dataConnectionMode = PASSIVE_LOCAL_DATA_CONNECTION_MODE; 736 // These will be set when just before a data connection is opened 737 // in __openDataConnection() 738 __passiveHost = null; 739 __passivePort = -1; 740 } 741 742 743 /**** 744 * Set the current data connection mode to 745 * <code> ACTIVE_REMOTE_DATA_CONNECTION </code>. Use this method only 746 * for server to server data transfers. This method issues a PORT 747 * command to the server, indicating the other server and port to which 748 * it should connect for data transfers. You must call this method 749 * before EVERY server to server transfer attempt. The FTPClient will 750 * NOT automatically continue to issue PORT commands. You also 751 * must remember to call 752 * <a href="#enterLocalActiveMode"> enterLocalActiveMode() </a> if you 753 * wish to return to the normal data connection mode. 754 * <p> 755 * @param host The passive mode server accepting connections for data 756 * transfers. 757 * @param port The passive mode server's data port. 758 * @return True if successfully completed, false if not. 759 * @exception FTPConnectionClosedException 760 * If the FTP server prematurely closes the connection as a result 761 * of the client being idle or some other reason causing the server 762 * to send FTP reply code 421. This exception may be caught either 763 * as an IOException or independently as itself. 764 * @exception IOException If an I/O error occurs while either sending a 765 * command to the server or receiving a reply from the server. 766 ***/ 767 public boolean enterRemoteActiveMode(InetAddress host, int port) 768 throws IOException 769 { 770 if (FTPReply.isPositiveCompletion(port(host, port))) 771 { 772 __dataConnectionMode = ACTIVE_REMOTE_DATA_CONNECTION_MODE; 773 __passiveHost = null; 774 __passivePort = -1; 775 return true; 776 } 777 return false; 778 } 779 780 /**** 781 * Set the current data connection mode to 782 * <code> PASSIVE_REMOTE_DATA_CONNECTION_MODE </code>. Use this 783 * method only for server to server data transfers. 784 * This method issues a PASV command to the server, telling it to 785 * open a data port to which the active server will connect to conduct 786 * data transfers. You must call this method 787 * before EVERY server to server transfer attempt. The FTPClient will 788 * NOT automatically continue to issue PASV commands. You also 789 * must remember to call 790 * <a href="#enterLocalActiveMode"> enterLocalActiveMode() </a> if you 791 * wish to return to the normal data connection mode. 792 * <p> 793 * @return True if successfully completed, false if not. 794 * @exception FTPConnectionClosedException 795 * If the FTP server prematurely closes the connection as a result 796 * of the client being idle or some other reason causing the server 797 * to send FTP reply code 421. This exception may be caught either 798 * as an IOException or independently as itself. 799 * @exception IOException If an I/O error occurs while either sending a 800 * command to the server or receiving a reply from the server. 801 ***/ 802 public boolean enterRemotePassiveMode() throws IOException 803 { 804 if (pasv() != FTPReply.ENTERING_PASSIVE_MODE) 805 return false; 806 807 __dataConnectionMode = PASSIVE_REMOTE_DATA_CONNECTION_MODE; 808 __parsePassiveModeReply((String)_replyLines.elementAt(0)); 809 810 return true; 811 } 812 813 /**** 814 * Returns the hostname or IP address (in the form of a string) returned 815 * by the server when entering passive mode. If not in passive mode, 816 * returns null. This method only returns a valid value AFTER a 817 * data connection has been opened after a call to 818 * <a href="#enterLocalPassiveMode">enterLocalPassiveMode()</a>. 819 * This is because FTPClient sends a PASV command to the server only 820 * just before opening a data connection, and not when you call 821 * <a href="#enterLocalPassiveMode">enterLocalPassiveMode()</a>. 822 * <p> 823 * @return The passive host name if in passive mode, otherwise null. 824 ***/ 825 public String getPassiveHost() 826 { 827 return __passiveHost; 828 } 829 830 /**** 831 * If in passive mode, returns the data port of the passive host. 832 * This method only returns a valid value AFTER a 833 * data connection has been opened after a call to 834 * <a href="#enterLocalPassiveMode">enterLocalPassiveMode()</a>. 835 * This is because FTPClient sends a PASV command to the server only 836 * just before opening a data connection, and not when you call 837 * <a href="#enterLocalPassiveMode">enterLocalPassiveMode()</a>. 838 * <p> 839 * @return The data port of the passive server. If not in passive 840 * mode, undefined. 841 ***/ 842 public int getPassivePort() 843 { 844 return __passivePort; 845 } 846 847 848 /**** 849 * Returns the current data connection mode (one of the 850 * <code> _DATA_CONNECTION_MODE </code> constants. 851 * <p> 852 * @return The current data connection mode (one of the 853 * <code> _DATA_CONNECTION_MODE </code> constants. 854 ***/ 855 public int getDataConnectionMode() 856 { 857 return __dataConnectionMode; 858 } 859 860 861 /**** 862 * Sets the file type to be transferred. This should be one of 863 * <code> FTP.ASCII_FILE_TYPE </code>, <code> FTP.IMAGE_FILE_TYPE </code>, 864 * etc. The file type only needs to be set when you want to change the 865 * type. After changing it, the new type stays in effect until you change 866 * it again. The default file type is <code> FTP.ASCII_FILE_TYPE </code> 867 * if this method is never called. 868 * <p> 869 * @param fileType The <code> _FILE_TYPE </code> constant indcating the 870 * type of file. 871 * @return True if successfully completed, false if not. 872 * @exception FTPConnectionClosedException 873 * If the FTP server prematurely closes the connection as a result 874 * of the client being idle or some other reason causing the server 875 * to send FTP reply code 421. This exception may be caught either 876 * as an IOException or independently as itself. 877 * @exception IOException If an I/O error occurs while either sending a 878 * command to the server or receiving a reply from the server. 879 ***/ 880 public boolean setFileType(int fileType) throws IOException 881 { 882 if (FTPReply.isPositiveCompletion(type(fileType))) 883 { 884 __fileType = fileType; 885 __fileFormat = FTP.NON_PRINT_TEXT_FORMAT; 886 return true; 887 } 888 return false; 889 } 890 891 892 /**** 893 * Sets the file type to be transferred and the format. The type should be 894 * one of <code> FTP.ASCII_FILE_TYPE </code>, 895 * <code> FTP.IMAGE_FILE_TYPE </code>, etc. The file type only needs to 896 * be set when you want to change the type. After changing it, the new 897 * type stays in effect until you change it again. The default file type 898 * is <code> FTP.ASCII_FILE_TYPE </code> if this method is never called. 899 * The format should be one of the FTP class <code> TEXT_FORMAT </code> 900 * constants, or if the type is <code> FTP.LOCAL_FILE_TYPE </code>, the 901 * format should be the byte size for that type. The default format 902 * is <code> FTP.NON_PRINT_TEXT_FORMAT </code> if this method is never 903 * called. 904 * <p> 905 * @param fileType The <code> _FILE_TYPE </code> constant indcating the 906 * type of file. 907 * @param formatOrByteSize The format of the file (one of the 908 * <code>_FORMAT</code> constants. In the case of 909 * <code>LOCAL_FILE_TYPE</code>, the byte size. 910 * <p> 911 * @return True if successfully completed, false if not. 912 * @exception FTPConnectionClosedException 913 * If the FTP server prematurely closes the connection as a result 914 * of the client being idle or some other reason causing the server 915 * to send FTP reply code 421. This exception may be caught either 916 * as an IOException or independently as itself. 917 * @exception IOException If an I/O error occurs while either sending a 918 * command to the server or receiving a reply from the server. 919 ***/ 920 public boolean setFileType(int fileType, int formatOrByteSize) 921 throws IOException 922 { 923 if (FTPReply.isPositiveCompletion(type(fileType, formatOrByteSize))) 924 { 925 __fileType = fileType; 926 __fileFormat = formatOrByteSize; 927 return true; 928 } 929 return false; 930 } 931 932 933 /**** 934 * Sets the file structure. The default structure is 935 * <code> FTP.FILE_STRUCTURE </code> if this method is never called. 936 * <p> 937 * @param structure The structure of the file (one of the FTP class 938 * <code>_STRUCTURE</code> constants). 939 * @return True if successfully completed, false if not. 940 * @exception FTPConnectionClosedException 941 * If the FTP server prematurely closes the connection as a result 942 * of the client being idle or some other reason causing the server 943 * to send FTP reply code 421. This exception may be caught either 944 * as an IOException or independently as itself. 945 * @exception IOException If an I/O error occurs while either sending a 946 * command to the server or receiving a reply from the server. 947 ***/ 948 public boolean setFileStructure(int structure) throws IOException 949 { 950 if (FTPReply.isPositiveCompletion(stru(structure))) 951 { 952 __fileStructure = structure; 953 return true; 954 } 955 return false; 956 } 957 958 959 /**** 960 * Sets the transfer mode. The default transfer mode 961 * <code> FTP.STREAM_TRANSFER_MODE </code> if this method is never called. 962 * <p> 963 * @param mode The new transfer mode to use (one of the FTP class 964 * <code>_TRANSFER_MODE</code> constants). 965 * @return True if successfully completed, false if not. 966 * @exception FTPConnectionClosedException 967 * If the FTP server prematurely closes the connection as a result 968 * of the client being idle or some other reason causing the server 969 * to send FTP reply code 421. This exception may be caught either 970 * as an IOException or independently as itself. 971 * @exception IOException If an I/O error occurs while either sending a 972 * command to the server or receiving a reply from the server. 973 ***/ 974 public boolean setFileTransferMode(int mode) throws IOException 975 { 976 if (FTPReply.isPositiveCompletion(mode(mode))) 977 { 978 __fileTransferMode = mode; 979 return true; 980 } 981 return false; 982 } 983 984 985 /**** 986 * Initiate a server to server file transfer. This method tells the 987 * server to which the client is connected to retrieve a given file from 988 * the other server. 989 * <p> 990 * @param filename The name of the file to retrieve. 991 * @return True if successfully completed, false if not. 992 * @exception FTPConnectionClosedException 993 * If the FTP server prematurely closes the connection as a result 994 * of the client being idle or some other reason causing the server 995 * to send FTP reply code 421. This exception may be caught either 996 * as an IOException or independently as itself. 997 * @exception IOException If an I/O error occurs while either sending a 998 * command to the server or receiving a reply from the server. 999 ***/ 1000 public boolean remoteRetrieve(String filename) throws IOException 1001 { 1002 if (__dataConnectionMode == ACTIVE_REMOTE_DATA_CONNECTION_MODE || 1003 __dataConnectionMode == PASSIVE_REMOTE_DATA_CONNECTION_MODE) 1004 return FTPReply.isPositivePreliminary(retr(filename)); 1005 return false; 1006 } 1007 1008 1009 /**** 1010 * Initiate a server to server file transfer. This method tells the 1011 * server to which the client is connected to store a file on 1012 * the other server using the given filename. The other server must 1013 * have had a <code> remoteRetrieve </code> issued to it by another 1014 * FTPClient. 1015 * <p> 1016 * @param filename The name to call the file that is to be stored. 1017 * @return True if successfully completed, false if not. 1018 * @exception FTPConnectionClosedException 1019 * If the FTP server prematurely closes the connection as a result 1020 * of the client being idle or some other reason causing the server 1021 * to send FTP reply code 421. This exception may be caught either 1022 * as an IOException or independently as itself. 1023 * @exception IOException If an I/O error occurs while either sending a 1024 * command to the server or receiving a reply from the server. 1025 ***/ 1026 public boolean remoteStore(String filename) throws IOException 1027 { 1028 if (__dataConnectionMode == ACTIVE_REMOTE_DATA_CONNECTION_MODE || 1029 __dataConnectionMode == PASSIVE_REMOTE_DATA_CONNECTION_MODE) 1030 return FTPReply.isPositivePreliminary(stor(filename)); 1031 return false; 1032 } 1033 1034 1035 /**** 1036 * Initiate a server to server file transfer. This method tells the 1037 * server to which the client is connected to store a file on 1038 * the other server using a unique filename based on the given filename. 1039 * The other server must have had a <code> remoteRetrieve </code> issued 1040 * to it by another FTPClient. 1041 * <p> 1042 * @param filename The name on which to base the filename of the file 1043 * that is to be stored. 1044 * @return True if successfully completed, false if not. 1045 * @exception FTPConnectionClosedException 1046 * If the FTP server prematurely closes the connection as a result 1047 * of the client being idle or some other reason causing the server 1048 * to send FTP reply code 421. This exception may be caught either 1049 * as an IOException or independently as itself. 1050 * @exception IOException If an I/O error occurs while either sending a 1051 * command to the server or receiving a reply from the server. 1052 ***/ 1053 public boolean remoteStoreUnique(String filename) throws IOException 1054 { 1055 if (__dataConnectionMode == ACTIVE_REMOTE_DATA_CONNECTION_MODE || 1056 __dataConnectionMode == PASSIVE_REMOTE_DATA_CONNECTION_MODE) 1057 return FTPReply.isPositivePreliminary(stou(filename)); 1058 return false; 1059 } 1060 1061 1062 /**** 1063 * Initiate a server to server file transfer. This method tells the 1064 * server to which the client is connected to store a file on 1065 * the other server using a unique filename. 1066 * The other server must have had a <code> remoteRetrieve </code> issued 1067 * to it by another FTPClient. Many FTP servers require that a base 1068 * filename be given from which the unique filename can be derived. For 1069 * those servers use the other version of <code> remoteStoreUnique</code> 1070 * <p> 1071 * @return True if successfully completed, false if not. 1072 * @exception FTPConnectionClosedException 1073 * If the FTP server prematurely closes the connection as a result 1074 * of the client being idle or some other reason causing the server 1075 * to send FTP reply code 421. This exception may be caught either 1076 * as an IOException or independently as itself. 1077 * @exception IOException If an I/O error occurs while either sending a 1078 * command to the server or receiving a reply from the server. 1079 ***/ 1080 public boolean remoteStoreUnique() throws IOException 1081 { 1082 if (__dataConnectionMode == ACTIVE_REMOTE_DATA_CONNECTION_MODE || 1083 __dataConnectionMode == PASSIVE_REMOTE_DATA_CONNECTION_MODE) 1084 return FTPReply.isPositivePreliminary(stou()); 1085 return false; 1086 } 1087 1088 // For server to server transfers 1089 /**** 1090 * Initiate a server to server file transfer. This method tells the 1091 * server to which the client is connected to append to a given file on 1092 * the other server. The other server must have had a 1093 * <code> remoteRetrieve </code> issued to it by another FTPClient. 1094 * <p> 1095 * @param filename The name of the file to be appended to, or if the 1096 * file does not exist, the name to call the file being stored. 1097 * <p> 1098 * @return True if successfully completed, false if not. 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 a 1105 * command to the server or receiving a reply from the server. 1106 ***/ 1107 public boolean remoteAppend(String filename) throws IOException 1108 { 1109 if (__dataConnectionMode == ACTIVE_REMOTE_DATA_CONNECTION_MODE || 1110 __dataConnectionMode == PASSIVE_REMOTE_DATA_CONNECTION_MODE) 1111 return FTPReply.isPositivePreliminary(stor(filename)); 1112 return false; 1113 } 1114 1115 /**** 1116 * There are a few FTPClient methods that do not complete the 1117 * entire sequence of FTP commands to complete a transaction. These 1118 * commands require some action by the programmer after the reception 1119 * of a positive intermediate command. After the programmer's code 1120 * completes its actions, it must call this method to receive 1121 * the completion reply from the server and verify the success of the 1122 * entire transaction. 1123 * <p> 1124 * For example, 1125 * <pre> 1126 * InputStream input; 1127 * OutputStream output; 1128 * input = new FileInputStream("foobaz.txt"); 1129 * output = ftp.storeFileStream("foobar.txt") 1130 * if(!FTPReply.isPositiveIntermediate(ftp.getReplyCode())) { 1131 * input.close(); 1132 * output.close(); 1133 * ftp.logout(); 1134 * ftp.disconnect(); 1135 * System.err.println("File transfer failed."); 1136 * System.exit(1); 1137 * } 1138 * Util.copyStream(input, output); 1139 * input.close(); 1140 * output.close(); 1141 * // Must call completePendingCommand() to finish command. 1142 * if(!ftp.completePendingCommand()) { 1143 * ftp.logout(); 1144 * ftp.disconnect(); 1145 * System.err.println("File transfer failed."); 1146 * System.exit(1); 1147 * } 1148 * </pre> 1149 * <p> 1150 * @return True if successfully completed, false if not. 1151 * @exception FTPConnectionClosedException 1152 * If the FTP server prematurely closes the connection as a result 1153 * of the client being idle or some other reason causing the server 1154 * to send FTP reply code 421. This exception may be caught either 1155 * as an IOException or independently as itself. 1156 * @exception IOException If an I/O error occurs while either sending a 1157 * command to the server or receiving a reply from the server. 1158 ***/ 1159 public boolean completePendingCommand() throws IOException 1160 { 1161 return FTPReply.isPositiveCompletion(getReply()); 1162 } 1163 1164 1165 /**** 1166 * Retrieves a named file from the server and writes it to the given 1167 * OutputStream. This method does NOT close the given OutputStream. 1168 * If the current file type is ASCII, line separators in the file are 1169 * converted to the local representation. 1170 * <p> 1171 * @param remote The name of the remote file. 1172 * @param local The local OutputStream to which to write the file. 1173 * @return True if successfully completed, false if not. 1174 * @exception FTPConnectionClosedException 1175 * If the FTP server prematurely closes the connection as a result 1176 * of the client being idle or some other reason causing the server 1177 * to send FTP reply code 421. This exception may be caught either 1178 * as an IOException or independently as itself. 1179 * @exception CopyStreamException If an I/O error occurs while actually 1180 * transferring the file. The CopyStreamException allows you to 1181 * determine the number of bytes transferred and the IOException 1182 * causing the error. This exception may be caught either 1183 * as an IOException or independently as itself. 1184 * @exception IOException If an I/O error occurs while either sending a 1185 * command to the server or receiving a reply from the server. 1186 ***/ 1187 public boolean retrieveFile(String remote, OutputStream local) 1188 throws IOException 1189 { 1190 InputStream input; 1191 Socket socket; 1192 1193 if ((socket = __openDataConnection(FTPCommand.RETR, remote)) == null) 1194 return false; 1195 1196 input = new BufferedInputStream(socket.getInputStream()); 1197 if (__fileType == ASCII_FILE_TYPE) 1198 input = new FromNetASCIIInputStream(input); 1199 // Treat everything else as binary for now 1200 try 1201 { 1202 Util.copyStream(input, local); 1203 } 1204 catch (IOException e) 1205 { 1206 try 1207 { 1208 socket.close(); 1209 } 1210 catch (IOException f) 1211 {} 1212 throw e; 1213 } 1214 socket.close(); 1215 return completePendingCommand(); 1216 } 1217 1218 /**** 1219 * Returns an InputStream from which a named file from the server 1220 * can be read. If the current file type is ASCII, the returned 1221 * InputStream will convert line separators in the file to 1222 * the local representation. You must close the InputStream when you 1223 * finish reading from it. The InputStream itself will take care of 1224 * closing the parent data connection socket upon being closed. To 1225 * finalize the file transfer you must call 1226 * <a href="#completePendingCommand"> completePendingCommand </a> and 1227 * check its return value to verify success. 1228 * <p> 1229 * @param remote The name of the remote file. 1230 * @return An InputStream from which the remote file can be read. If 1231 * the data connection cannot be opened (e.g., the file does not 1232 * exist), null is returned (in which case you may check the reply 1233 * code to determine the exact reason for failure). 1234 * @exception FTPConnectionClosedException 1235 * If the FTP server prematurely closes the connection as a result 1236 * of the client being idle or some other reason causing the server 1237 * to send FTP reply code 421. This exception may be caught either 1238 * as an IOException or independently as itself. 1239 * @exception IOException If an I/O error occurs while either sending a 1240 * command to the server or receiving a reply from the server. 1241 ***/ 1242 public InputStream retrieveFileStream(String remote) throws IOException 1243 { 1244 InputStream input; 1245 Socket socket; 1246 1247 if ((socket = __openDataConnection(FTPCommand.RETR, remote)) == null) 1248 return null; 1249 1250 input = socket.getInputStream(); 1251 if (__fileType == ASCII_FILE_TYPE) 1252 input = new FromNetASCIIInputStream(input); 1253 return new org.apache.commons.net.io.SocketInputStream(socket, input); 1254 } 1255 1256 1257 /**** 1258 * Stores a file on the server using the given name and taking input 1259 * from the given InputStream. This method does NOT close the given 1260 * InputStream. If the current file type is ASCII, line separators in 1261 * the file are transparently converted to the NETASCII format (i.e., 1262 * you should not attempt to create a special InputStream to do this). 1263 * <p> 1264 * @param remote The name to give the remote file. 1265 * @param local The local InputStream from which to read the file. 1266 * @return True if successfully completed, false if not. 1267 * @exception FTPConnectionClosedException 1268 * If the FTP server prematurely closes the connection as a result 1269 * of the client being idle or some other reason causing the server 1270 * to send FTP reply code 421. This exception may be caught either 1271 * as an IOException or independently as itself. 1272 * @exception CopyStreamException If an I/O error occurs while actually 1273 * transferring the file. The CopyStreamException allows you to 1274 * determine the number of bytes transferred and the IOException 1275 * causing the error. This exception may be caught either 1276 * as an IOException or independently as itself. 1277 * @exception IOException If an I/O error occurs while either sending a 1278 * command to the server or receiving a reply from the server. 1279 ***/ 1280 public boolean storeFile(String remote, InputStream local) 1281 throws IOException 1282 { 1283 return __storeFile(FTPCommand.STOR, remote, local); 1284 } 1285 1286 1287 /**** 1288 * Returns an OutputStream through which data can be written to store 1289 * a file on the server using the given name. If the current file type 1290 * is ASCII, the returned OutputStream will convert line separators in 1291 * the file to the NETASCII format (i.e., you should not attempt to 1292 * create a special OutputStream to do this). You must close the 1293 * OutputStream when you finish writing to it. The OutputStream itself 1294 * will take care of closing the parent data connection socket upon being 1295 * closed. To finalize the file transfer you must call 1296 * <a href="#completePendingCommand"> completePendingCommand </a> and 1297 * check its return value to verify success. 1298 * <p> 1299 * @param remote The name to give the remote file. 1300 * @return An OutputStream through which the remote file can be written. If 1301 * the data connection cannot be opened (e.g., the file does not 1302 * exist), null is returned (in which case you may check the reply 1303 * code to determine the exact reason for failure). 1304 * @exception FTPConnectionClosedException 1305 * If the FTP server prematurely closes the connection as a result 1306 * of the client being idle or some other reason causing the server 1307 * to send FTP reply code 421. This exception may be caught either 1308 * as an IOException or independently as itself. 1309 * @exception IOException If an I/O error occurs while either sending a 1310 * command to the server or receiving a reply from the server. 1311 ***/ 1312 public OutputStream storeFileStream(String remote) throws IOException 1313 { 1314 return __storeFileStream(FTPCommand.STOR, remote); 1315 } 1316 1317 /**** 1318 * Appends to a file on the server with the given name, taking input 1319 * from the given InputStream. This method does NOT close the given 1320 * InputStream. If the current file type is ASCII, line separators in 1321 * the file are transparently converted to the NETASCII format (i.e., 1322 * you should not attempt to create a special InputStream to do this). 1323 * <p> 1324 * @param remote The name of the remote file. 1325 * @param local The local InputStream from which to read the data to 1326 * be appended to the remote file. 1327 * @return True if successfully completed, false if not. 1328 * @exception FTPConnectionClosedException 1329 * If the FTP server prematurely closes the connection as a result 1330 * of the client being idle or some other reason causing the server 1331 * to send FTP reply code 421. This exception may be caught either 1332 * as an IOException or independently as itself. 1333 * @exception CopyStreamException If an I/O error occurs while actually 1334 * transferring the file. The CopyStreamException allows you to 1335 * determine the number of bytes transferred and the IOException 1336 * causing the error. This exception may be caught either 1337 * as an IOException or independently as itself. 1338 * @exception IOException If an I/O error occurs while either sending a 1339 * command to the server or receiving a reply from the server. 1340 ***/ 1341 public boolean appendFile(String remote, InputStream local) 1342 throws IOException 1343 { 1344 return __storeFile(FTPCommand.APPE, remote, local); 1345 } 1346 1347 /**** 1348 * Returns an OutputStream through which data can be written to append 1349 * to a file on the server with the given name. If the current file type 1350 * is ASCII, the returned OutputStream will convert line separators in 1351 * the file to the NETASCII format (i.e., you should not attempt to 1352 * create a special OutputStream to do this). You must close the 1353 * OutputStream when you finish writing to it. The OutputStream itself 1354 * will take care of closing the parent data connection socket upon being 1355 * closed. To finalize the file transfer you must call 1356 * <a href="#completePendingCommand"> completePendingCommand </a> and 1357 * check its return value to verify success. 1358 * <p> 1359 * @param remote The name of the remote file. 1360 * @return An OutputStream through which the remote file can be appended. 1361 * If the data connection cannot be opened (e.g., the file does not 1362 * exist), null is returned (in which case you may check the reply 1363 * code to determine the exact reason for failure). 1364 * @exception FTPConnectionClosedException 1365 * If the FTP server prematurely closes the connection as a result 1366 * of the client being idle or some other reason causing the server 1367 * to send FTP reply code 421. This exception may be caught either 1368 * as an IOException or independently as itself. 1369 * @exception IOException If an I/O error occurs while either sending a 1370 * command to the server or receiving a reply from the server. 1371 ***/ 1372 public OutputStream appendFileStream(String remote) throws IOException 1373 { 1374 return __storeFileStream(FTPCommand.APPE, remote); 1375 } 1376 1377 /**** 1378 * Stores a file on the server using a unique name derived from the 1379 * given name and taking input 1380 * from the given InputStream. This method does NOT close the given 1381 * InputStream. If the current file type is ASCII, line separators in 1382 * the file are transparently converted to the NETASCII format (i.e., 1383 * you should not attempt to create a special InputStream to do this). 1384 * <p> 1385 * @param remote The name on which to base the unique name given to 1386 * the remote file. 1387 * @param local The local InputStream from which to read the file. 1388 * @return True if successfully completed, false if not. 1389 * @exception FTPConnectionClosedException 1390 * If the FTP server prematurely closes the connection as a result 1391 * of the client being idle or some other reason causing the server 1392 * to send FTP reply code 421. This exception may be caught either 1393 * as an IOException or independently as itself. 1394 * @exception CopyStreamException If an I/O error occurs while actually 1395 * transferring the file. The CopyStreamException allows you to 1396 * determine the number of bytes transferred and the IOException 1397 * causing the error. This exception may be caught either 1398 * as an IOException or independently as itself. 1399 * @exception IOException If an I/O error occurs while either sending a 1400 * command to the server or receiving a reply from the server. 1401 ***/ 1402 public boolean storeUniqueFile(String remote, InputStream local) 1403 throws IOException 1404 { 1405 return __storeFile(FTPCommand.STOU, remote, local); 1406 } 1407 1408 1409 /**** 1410 * Returns an OutputStream through which data can be written to store 1411 * a file on the server using a unique name derived from the given name. 1412 * If the current file type 1413 * is ASCII, the returned OutputStream will convert line separators in 1414 * the file to the NETASCII format (i.e., you should not attempt to 1415 * create a special OutputStream to do this). You must close the 1416 * OutputStream when you finish writing to it. The OutputStream itself 1417 * will take care of closing the parent data connection socket upon being 1418 * closed. To finalize the file transfer you must call 1419 * <a href="#completePendingCommand"> completePendingCommand </a> and 1420 * check its return value to verify success. 1421 * <p> 1422 * @param remote The name on which to base the unique name given to 1423 * the remote file. 1424 * @return An OutputStream through which the remote file can be written. If 1425 * the data connection cannot be opened (e.g., the file does not 1426 * exist), null is returned (in which case you may check the reply 1427 * code to determine the exact reason for failure). 1428 * @exception FTPConnectionClosedException 1429 * If the FTP server prematurely closes the connection as a result 1430 * of the client being idle or some other reason causing the server 1431 * to send FTP reply code 421. This exception may be caught either 1432 * as an IOException or independently as itself. 1433 * @exception IOException If an I/O error occurs while either sending a 1434 * command to the server or receiving a reply from the server. 1435 ***/ 1436 public OutputStream storeUniqueFileStream(String remote) throws IOException 1437 { 1438 return __storeFileStream(FTPCommand.STOU, remote); 1439 } 1440 1441 /**** 1442 * Stores a file on the server using a unique name assigned by the 1443 * server and taking input from the given InputStream. This method does 1444 * NOT close the given 1445 * InputStream. If the current file type is ASCII, line separators in 1446 * the file are transparently converted to the NETASCII format (i.e., 1447 * you should not attempt to create a special InputStream to do this). 1448 * <p> 1449 * @param remote The name to give the remote file. 1450 * @param local The local InputStream from which to read the file. 1451 * @return True if successfully completed, false if not. 1452 * @exception FTPConnectionClosedException 1453 * If the FTP server prematurely closes the connection as a result 1454 * of the client being idle or some other reason causing the server 1455 * to send FTP reply code 421. This exception may be caught either 1456 * as an IOException or independently as itself. 1457 * @exception CopyStreamException If an I/O error occurs while actually 1458 * transferring the file. The CopyStreamException allows you to 1459 * determine the number of bytes transferred and the IOException 1460 * causing the error. This exception may be caught either 1461 * as an IOException or independently as itself. 1462 * @exception IOException If an I/O error occurs while either sending a 1463 * command to the server or receiving a reply from the server. 1464 ***/ 1465 public boolean storeUniqueFile(InputStream local) throws IOException 1466 { 1467 return __storeFile(FTPCommand.STOU, null, local); 1468 } 1469 1470 /**** 1471 * Returns an OutputStream through which data can be written to store 1472 * a file on the server using a unique name assigned by the server. 1473 * If the current file type 1474 * is ASCII, the returned OutputStream will convert line separators in 1475 * the file to the NETASCII format (i.e., you should not attempt to 1476 * create a special OutputStream to do this). You must close the 1477 * OutputStream when you finish writing to it. The OutputStream itself 1478 * will take care of closing the parent data connection socket upon being 1479 * closed. To finalize the file transfer you must call 1480 * <a href="#completePendingCommand"> completePendingCommand </a> and 1481 * check its return value to verify success. 1482 * <p> 1483 * @param remote The name to give the remote file. 1484 * @return An OutputStream through which the remote file can be written. If 1485 * the data connection cannot be opened (e.g., the file does not 1486 * exist), null is returned (in which case you may check the reply 1487 * code to determine the exact reason for failure). 1488 * @exception FTPConnectionClosedException 1489 * If the FTP server prematurely closes the connection as a result 1490 * of the client being idle or some other reason causing the server 1491 * to send FTP reply code 421. This exception may be caught either 1492 * as an IOException or independently as itself. 1493 * @exception IOException If an I/O error occurs while either sending a 1494 * command to the server or receiving a reply from the server. 1495 ***/ 1496 public OutputStream storeUniqueFileStream() throws IOException 1497 { 1498 return __storeFileStream(FTPCommand.STOU, null); 1499 } 1500 1501 /**** 1502 * Reserve a number of bytes on the server for the next file transfer. 1503 * <p> 1504 * @param bytes The number of bytes which the server should allocate. 1505 * @return True if successfully completed, false if not. 1506 * @exception FTPConnectionClosedException 1507 * If the FTP server prematurely closes the connection as a result 1508 * of the client being idle or some other reason causing the server 1509 * to send FTP reply code 421. This exception may be caught either 1510 * as an IOException or independently as itself. 1511 * @exception IOException If an I/O error occurs while either sending a 1512 * command to the server or receiving a reply from the server. 1513 ***/ 1514 public boolean allocate(int bytes) throws IOException 1515 { 1516 return FTPReply.isPositiveCompletion(allo(bytes)); 1517 } 1518 1519 1520 /**** 1521 * Reserve space on the server for the next file transfer. 1522 * <p> 1523 * @param bytes The number of bytes which the server should allocate. 1524 * @param bytes The size of a file record. 1525 * @return True if successfully completed, false if not. 1526 * @exception FTPConnectionClosedException 1527 * If the FTP server prematurely closes the connection as a result 1528 * of the client being idle or some other reason causing the server 1529 * to send FTP reply code 421. This exception may be caught either 1530 * as an IOException or independently as itself. 1531 * @exception IOException If an I/O error occurs while either sending a 1532 * command to the server or receiving a reply from the server. 1533 ***/ 1534 public boolean allocate(int bytes, int recordSize) throws IOException 1535 { 1536 return FTPReply.isPositiveCompletion(allo(bytes, recordSize)); 1537 } 1538 1539 1540 /**** 1541 * Restart a <code>STREAM_TRANSFER_MODE</code> file transfer starting 1542 * from the given offset. This will only work on FTP servers supporting 1543 * the REST comand for the stream transfer mode. However, most FTP 1544 * servers support this. Any subsequent file transfer will start 1545 * reading or writing the remote file from the indicated offset. 1546 * <p> 1547 * @param offset The offset into the remote file at which to start the 1548 * next file transfer. 1549 * @return True if successfully completed, false if not. 1550 * @exception FTPConnectionClosedException 1551 * If the FTP server prematurely closes the connection as a result 1552 * of the client being idle or some other reason causing the server 1553 * to send FTP reply code 421. This exception may be caught either 1554 * as an IOException or independently as itself. 1555 * @exception IOException If an I/O error occurs while either sending a 1556 * command to the server or receiving a reply from the server. 1557 ***/ 1558 private boolean restart(long offset) throws IOException 1559 { 1560 __restartOffset = 0; 1561 return FTPReply.isPositiveIntermediate(rest(Long.toString(offset))); 1562 } 1563 1564 /**** 1565 * Sets the restart offset. The restart command is sent to the server 1566 * only before sending the file transfer command. When this is done, 1567 * the restart marker is reset to zero. 1568 * <p> 1569 * @param offset The offset into the remote file at which to start the 1570 * next file transfer. This must be a value greater than or 1571 * equal to zero. 1572 ***/ 1573 public void setRestartOffset(long offset) 1574 { 1575 if (offset >= 0) 1576 __restartOffset = offset; 1577 } 1578 1579 /**** 1580 * Fetches the restart offset. 1581 * <p> 1582 * @return offset The offset into the remote file at which to start the 1583 * next file transfer. 1584 ***/ 1585 public long getRestartOffset() 1586 { 1587 return __restartOffset; 1588 } 1589 1590 1591 1592 /**** 1593 * Renames a remote file. 1594 * <p> 1595 * @param from The name of the remote file to rename. 1596 * @param to The new name of the remote file. 1597 * @return True if successfully completed, false if not. 1598 * @exception FTPConnectionClosedException 1599 * If the FTP server prematurely closes the connection as a result 1600 * of the client being idle or some other reason causing the server 1601 * to send FTP reply code 421. This exception may be caught either 1602 * as an IOException or independently as itself. 1603 * @exception IOException If an I/O error occurs while either sending a 1604 * command to the server or receiving a reply from the server. 1605 ***/ 1606 public boolean rename(String from, String to) throws IOException 1607 { 1608 if (!FTPReply.isPositiveIntermediate(rnfr(from))) 1609 return false; 1610 1611 return FTPReply.isPositiveCompletion(rnto(to)); 1612 } 1613 1614 1615 /**** 1616 * Abort a transfer in progress. 1617 * <p> 1618 * @return True if successfully completed, false if not. 1619 * @exception FTPConnectionClosedException 1620 * If the FTP server prematurely closes the connection as a result 1621 * of the client being idle or some other reason causing the server 1622 * to send FTP reply code 421. This exception may be caught either 1623 * as an IOException or independently as itself. 1624 * @exception IOException If an I/O error occurs while either sending a 1625 * command to the server or receiving a reply from the server. 1626 ***/ 1627 public boolean abort() throws IOException 1628 { 1629 return FTPReply.isPositiveCompletion(abor()); 1630 } 1631 1632 /**** 1633 * Deletes a file on the FTP server. 1634 * <p> 1635 * @param pathname The pathname of the file to be deleted. 1636 * @return True if successfully completed, false if not. 1637 * @exception FTPConnectionClosedException 1638 * If the FTP server prematurely closes the connection as a result 1639 * of the client being idle or some other reason causing the server 1640 * to send FTP reply code 421. This exception may be caught either 1641 * as an IOException or independently as itself. 1642 * @exception IOException If an I/O error occurs while either sending a 1643 * command to the server or receiving a reply from the server. 1644 ***/ 1645 public boolean deleteFile(String pathname) throws IOException 1646 { 1647 return FTPReply.isPositiveCompletion(dele(pathname)); 1648 } 1649 1650 1651 /**** 1652 * Removes a directory on the FTP server (if empty). 1653 * <p> 1654 * @param pathname The pathname of the directory to remove. 1655 * @return True if successfully completed, false if not. 1656 * @exception FTPConnectionClosedException 1657 * If the FTP server prematurely closes the connection as a result 1658 * of the client being idle or some other reason causing the server 1659 * to send FTP reply code 421. This exception may be caught either 1660 * as an IOException or independently as itself. 1661 * @exception IOException If an I/O error occurs while either sending a 1662 * command to the server or receiving a reply from the server. 1663 ***/ 1664 public boolean removeDirectory(String pathname) throws IOException 1665 { 1666 return FTPReply.isPositiveCompletion(rmd(pathname)); 1667 } 1668 1669 1670 /**** 1671 * Creates a new subdirectory on the FTP server in the current directory 1672 * (if a relative pathname is given) or where specified (if an absolute 1673 * pathname is given). 1674 * <p> 1675 * @param pathname The pathname of the directory to create. 1676 * @return True if successfully completed, false if not. 1677 * @exception FTPConnectionClosedException 1678 * If the FTP server prematurely closes the connection as a result 1679 * of the client being idle or some other reason causing the server 1680 * to send FTP reply code 421. This exception may be caught either 1681 * as an IOException or independently as itself. 1682 * @exception IOException If an I/O error occurs while either sending a 1683 * command to the server or receiving a reply from the server. 1684 ***/ 1685 public boolean makeDirectory(String pathname) throws IOException 1686 { 1687 return FTPReply.isPositiveCompletion(mkd(pathname)); 1688 } 1689 1690 1691 /**** 1692 * Returns the pathname of the current working directory. 1693 * <p> 1694 * @return The pathname of the current working directory. If it cannot 1695 * be obtained, returns null. 1696 * @exception FTPConnectionClosedException 1697 * If the FTP server prematurely closes the connection as a result 1698 * of the client being idle or some other reason causing the server 1699 * to send FTP reply code 421. This exception may be caught either 1700 * as an IOException or independently as itself. 1701 * @exception IOException If an I/O error occurs while either sending a 1702 * command to the server or receiving a reply from the server. 1703 ***/ 1704 public String printWorkingDirectory() throws IOException 1705 { 1706 if (pwd() != FTPReply.PATHNAME_CREATED) 1707 return null; 1708 1709 return __parsePathname((String)_replyLines.elementAt(0)); 1710 } 1711 1712 1713 /**** 1714 * Send a site specific command. 1715 * <p> 1716 * @param argument The site specific command and arguments. 1717 * @return True if successfully completed, false if not. 1718 * @exception FTPConnectionClosedException 1719 * If the FTP server prematurely closes the connection as a result 1720 * of the client being idle or some other reason causing the server 1721 * to send FTP reply code 421. This exception may be caught either 1722 * as an IOException or independently as itself. 1723 * @exception IOException If an I/O error occurs while either sending a 1724 * command to the server or receiving a reply from the server. 1725 ***/ 1726 public boolean sendSiteCommand(String arguments) throws IOException 1727 { 1728 return FTPReply.isPositiveCompletion(site(arguments)); 1729 } 1730 1731 1732 /**** 1733 * Fetches the system type name from the server and returns the string. 1734 * <p> 1735 * @return The system type name obtained from the server. null if the 1736 * information could not be obtained. 1737 * @exception FTPConnectionClosedException 1738 * If the FTP server prematurely closes the connection as a result 1739 * of the client being idle or some other reason causing the server 1740 * to send FTP reply code 421. This exception may be caught either 1741 * as an IOException or independently as itself. 1742 * @exception IOException If an I/O error occurs while either sending a 1743 * command to the server or receiving a reply from the server. 1744 ***/ 1745 public String getSystemName() throws IOException 1746 { 1747 if (syst() == FTPReply.NAME_SYSTEM_TYPE) 1748 return ((String)_replyLines.elementAt(0)).substring(4); 1749 1750 return null; 1751 } 1752 1753 1754 /**** 1755 * Fetches the system help information from the server and returns the 1756 * full string. 1757 * <p> 1758 * @return The system help string obtained from the server. null if the 1759 * information could not be obtained. 1760 * @exception FTPConnectionClosedException 1761 * If the FTP server prematurely closes the connection as a result 1762 * of the client being idle or some other reason causing the server 1763 * to send FTP reply code 421. This exception may be caught either 1764 * as an IOException or independently as itself. 1765 * @exception IOException If an I/O error occurs while either sending a 1766 * command to the server or receiving a reply from the server. 1767 ***/ 1768 public String listHelp() throws IOException 1769 { 1770 if (FTPReply.isPositiveCompletion(help())) 1771 return getReplyString(); 1772 return null; 1773 } 1774 1775 1776 /**** 1777 * Fetches the help information for a given command from the server and 1778 * returns the full string. 1779 * <p> 1780 * @param The command on which to ask for help. 1781 * @return The command help string obtained from the server. null if the 1782 * information could not be obtained. 1783 * @exception FTPConnectionClosedException 1784 * If the FTP server prematurely closes the connection as a result 1785 * of the client being idle or some other reason causing the server 1786 * to send FTP reply code 421. This exception may be caught either 1787 * as an IOException or independently as itself. 1788 * @exception IOException If an I/O error occurs while either sending a 1789 * command to the server or receiving a reply from the server. 1790 ***/ 1791 public String listHelp(String command) throws IOException 1792 { 1793 if (FTPReply.isPositiveCompletion(help(command))) 1794 return getReplyString(); 1795 return null; 1796 } 1797 1798 1799 /**** 1800 * Sends a NOOP command to the FTP server. This is useful for preventing 1801 * server timeouts. 1802 * <p> 1803 * @return True if successfully completed, false if not. 1804 * @exception FTPConnectionClosedException 1805 * If the FTP server prematurely closes the connection as a result 1806 * of the client being idle or some other reason causing the server 1807 * to send FTP reply code 421. This exception may be caught either 1808 * as an IOException or independently as itself. 1809 * @exception IOException If an I/O error occurs while either sending a 1810 * command to the server or receiving a reply from the server. 1811 ***/ 1812 public boolean sendNoOp() throws IOException 1813 { 1814 return FTPReply.isPositiveCompletion(noop()); 1815 } 1816 1817 1818 /**** 1819 * Obtain a list of filenames in a directory (or just the name of a given 1820 * file, which is not particularly useful). This information is obtained 1821 * through the NLST command. If the given pathname is a directory and 1822 * contains no files, a zero length array is returned only 1823 * if the FTP server returned a positive completion code, otherwise 1824 * null is returned (the FTP server returned a 550 error No files found.). 1825 * If the directory is not empty, an array of filenames in the directory is 1826 * returned. If the pathname corresponds 1827 * to a file, only that file will be listed. The server may or may not 1828 * expand glob expressions. 1829 * <p> 1830 * @param pathname The file or directory to list. 1831 * @return The list of filenames contained in the given path. null if 1832 * the list could not be obtained. If there are no filenames in 1833 * the directory, a zero-length array is returned. 1834 * @exception FTPConnectionClosedException 1835 * If the FTP server prematurely closes the connection as a result 1836 * of the client being idle or some other reason causing the server 1837 * to send FTP reply code 421. This exception may be caught either 1838 * as an IOException or independently as itself. 1839 * @exception IOException If an I/O error occurs while either sending a 1840 * command to the server or receiving a reply from the server. 1841 ***/ 1842 public String[] listNames(String pathname) throws IOException 1843 { 1844 String line; 1845 Socket socket; 1846 BufferedReader reader; 1847 Vector results; 1848 1849 if ((socket = __openDataConnection(FTPCommand.NLST, pathname)) == null) 1850 return null; 1851 1852 reader = 1853 new BufferedReader(new InputStreamReader(socket.getInputStream())); 1854 1855 results = new Vector(); 1856 while ((line = reader.readLine()) != null) 1857 results.addElement(line); 1858 reader.close(); 1859 socket.close(); 1860 1861 if (completePendingCommand()) 1862 { 1863 String[] result; 1864 result = new String[results.size()]; 1865 results.copyInto(result); 1866 return result; 1867 } 1868 1869 return null; 1870 } 1871 1872 1873 /**** 1874 * Obtain a list of filenames in the current working directory 1875 * This information is obtained through the NLST command. If the current 1876 * directory contains no files, a zero length array is returned only 1877 * if the FTP server returned a positive completion code, otherwise, 1878 * null is returned (the FTP server returned a 550 error No files found.). 1879 * If the directory is not empty, an array of filenames in the directory is 1880 * returned. 1881 * <p> 1882 * @return The list of filenames contained in the current working 1883 * directory. null if the list could not be obtained. 1884 * If there are no filenames in the directory, a zero-length array 1885 * is returned. 1886 * @exception FTPConnectionClosedException 1887 * If the FTP server prematurely closes the connection as a result 1888 * of the client being idle or some other reason causing the server 1889 * to send FTP reply code 421. This exception may be caught either 1890 * as an IOException or independently as itself. 1891 * @exception IOException If an I/O error occurs while either sending a 1892 * command to the server or receiving a reply from the server. 1893 ***/ 1894 public String[] listNames() throws IOException 1895 { 1896 return listNames(null); 1897 } 1898 1899 1900 1901 /**** 1902 * Using a programmer specified <code> FTPFileListParser </code>, obtain a 1903 * list of file information for a directory or information for 1904 * just a single file. This information is obtained through the LIST 1905 * command. The contents of the returned array is determined by the 1906 * <code> FTPFileListParser </code> used. 1907 * The server may or may not expand glob expressions. You should avoid 1908 * using glob expressions because the return format for glob listings 1909 * differs from server to server and will likely cause this method to fail. 1910 * <p> 1911 * @param parser The <code> FTPFileListParser </code> that should be 1912 * used to parse the server file listing. 1913 * @param pathname The file or directory to list. 1914 * @return The list of file information contained in the given path in 1915 * the format determined by the <code> parser </code> parameter. 1916 * @exception FTPConnectionClosedException 1917 * If the FTP server prematurely closes the connection as a result 1918 * of the client being idle or some other reason causing the server 1919 * to send FTP reply code 421. This exception may be caught either 1920 * as an IOException or independently as itself. 1921 * @exception IOException If an I/O error occurs while either sending a 1922 * command to the server or receiving a reply from the server. 1923 ***/ 1924 public FTPFile[] listFiles(FTPFileListParser parser, String pathname) 1925 throws IOException 1926 { 1927 Socket socket; 1928 FTPFile[] results; 1929 1930 if ((socket = __openDataConnection(FTPCommand.LIST, pathname)) == null) 1931 return null; 1932 1933 results = parser.parseFileList(socket.getInputStream()); 1934 1935 socket.close(); 1936 1937 completePendingCommand(); 1938 1939 return results; 1940 } 1941 1942 1943 /**** 1944 * Using a programmer specified <code> FTPFileListParser </code>, 1945 * obtain a list of file information for the current working directory. 1946 * This information is obtained through the LIST command. 1947 * The contents of the array returned is determined by the 1948 * <code> FTPFileListParser </code> used. 1949 * <p> 1950 * @param parser The <code> FTPFileListParser </code> that should be 1951 * used to parse the server file listing. 1952 * @return The list of file information contained in the given path in 1953 * the format determined by the <code> parser </code> parameter. 1954 * @exception FTPConnectionClosedException 1955 * If the FTP server prematurely closes the connection as a result 1956 * of the client being idle or some other reason causing the server 1957 * to send FTP reply code 421. This exception may be caught either 1958 * as an IOException or independently as itself. 1959 * @exception IOException If an I/O error occurs while either sending a 1960 * command to the server or receiving a reply from the server. 1961 ***/ 1962 public FTPFile[] listFiles(FTPFileListParser parser) throws IOException 1963 { 1964 return listFiles(parser, null); 1965 } 1966 1967 1968 /**** 1969 * Using the <code> DefaultFTPFileListParser </code>, obtain a list of 1970 * file information 1971 * for a directory or information for just a single file. This information 1972 * is obtained through the LIST command. If the given 1973 * pathname is a directory and contains no files, <code> null </code> is 1974 * returned, otherwise an array of <code> FTPFile </code> instances 1975 * representing the files in the directory is returned. 1976 * If the pathname corresponds to a file, only the information for that 1977 * file will be contained in the array (which will be of length 1). The 1978 * server may or may not expand glob expressions. You should avoid using 1979 * glob expressions because the return format for glob listings differs 1980 * from server to server and will likely cause this method to fail. 1981 * <p> 1982 * @param pathname The file or directory to list. 1983 * @return The list of file information contained in the given path. null 1984 * if the list could not be obtained or if there are no files in 1985 * the directory. 1986 * @exception FTPConnectionClosedException 1987 * If the FTP server prematurely closes the connection as a result 1988 * of the client being idle or some other reason causing the server 1989 * to send FTP reply code 421. This exception may be caught either 1990 * as an IOException or independently as itself. 1991 * @exception IOException If an I/O error occurs while either sending a 1992 * command to the server or receiving a reply from the server. 1993 ***/ 1994 public FTPFile[] listFiles(String pathname) throws IOException 1995 { 1996 return listFiles(__fileListParser, pathname); 1997 } 1998 1999 /**** 2000 * Using the <code> DefaultFTPFileListParser </code>, obtain a list of 2001 * file information for the current working directory. This information 2002 * is obtained through the LIST command. If the given 2003 * current directory contains no files null is returned, otherwise an 2004 * array of <code> FTPFile </code> instances representing the files in the 2005 * directory is returned. 2006 * <p> 2007 * @return The list of file information contained in the current working 2008 * directory. null if the list could not be obtained or if there are 2009 * no files in the directory. 2010 * @exception FTPConnectionClosedException 2011 * If the FTP server prematurely closes the connection as a result 2012 * of the client being idle or some other reason causing the server 2013 * to send FTP reply code 421. This exception may be caught either 2014 * as an IOException or independently as itself. 2015 * @exception IOException If an I/O error occurs while either sending a 2016 * command to the server or receiving a reply from the server. 2017 ***/ 2018 public FTPFile[] listFiles() throws IOException 2019 { 2020 return listFiles(__fileListParser); 2021 } 2022 2023 2024 /**** 2025 * Issue the FTP STAT command to the server. 2026 * <p> 2027 * @return The status information returned by the server. 2028 * @exception FTPConnectionClosedException 2029 * If the FTP server prematurely closes the connection as a result 2030 * of the client being idle or some other reason causing the server 2031 * to send FTP reply code 421. This exception may be caught either 2032 * as an IOException or independently as itself. 2033 * @exception IOException If an I/O error occurs while either sending a 2034 * command to the server or receiving a reply from the server. 2035 ***/ 2036 public String getStatus() throws IOException 2037 { 2038 if (FTPReply.isPositiveCompletion(stat())) 2039 return getReplyString(); 2040 return null; 2041 } 2042 2043 2044 /**** 2045 * Issue the FTP STAT command to the server for a given pathname. This 2046 * should produce a listing of the file or directory. 2047 * <p> 2048 * @return The status information returned by the server. 2049 * @exception FTPConnectionClosedException 2050 * If the FTP server prematurely closes the connection as a result 2051 * of the client being idle or some other reason causing the server 2052 * to send FTP reply code 421. This exception may be caught either 2053 * as an IOException or independently as itself. 2054 * @exception IOException If an I/O error occurs while either sending a 2055 * command to the server or receiving a reply from the server. 2056 ***/ 2057 public String getStatus(String pathname) throws IOException 2058 { 2059 if (FTPReply.isPositiveCompletion(stat(pathname))) 2060 return getReplyString(); 2061 return null; 2062 } 2063 2064 2065 }

This page was automatically generated by Maven