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