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.SocketException; 028 import java.net.SocketTimeoutException; 029 import java.util.ArrayList; 030 031 import org.apache.commons.net.MalformedServerReplyException; 032 import org.apache.commons.net.ProtocolCommandSupport; 033 import org.apache.commons.net.SocketClient; 034 import org.apache.commons.net.io.CRLFLineReader; 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 Rory Winston 090 * @author Joseph Hindsley 091 * @see FTPClient 092 * @see FTPConnectionClosedException 093 * @see org.apache.commons.net.MalformedServerReplyException 094 * @version $Id: FTP.java 1299238 2012-03-10 17:12:28Z sebb $ 095 ***/ 096 097 public class FTP extends SocketClient 098 { 099 /*** The default FTP data port (20). ***/ 100 public static final int DEFAULT_DATA_PORT = 20; 101 /*** The default FTP control port (21). ***/ 102 public static final int DEFAULT_PORT = 21; 103 104 /*** 105 * A constant used to indicate the file(s) being transfered should 106 * be treated as ASCII. This is the default file type. All constants 107 * ending in <code>FILE_TYPE</code> are used to indicate file types. 108 ***/ 109 public static final int ASCII_FILE_TYPE = 0; 110 111 /*** 112 * A constant used to indicate the file(s) being transfered should 113 * be treated as EBCDIC. Note however that there are several different 114 * EBCDIC formats. All constants ending in <code>FILE_TYPE</code> 115 * are used to indicate file types. 116 ***/ 117 public static final int EBCDIC_FILE_TYPE = 1; 118 119 120 /*** 121 * A constant used to indicate the file(s) being transfered should 122 * be treated as a binary image, i.e., no translations should be 123 * performed. All constants ending in <code>FILE_TYPE</code> are used to 124 * indicate file types. 125 ***/ 126 public static final int BINARY_FILE_TYPE = 2; 127 128 /*** 129 * A constant used to indicate the file(s) being transfered should 130 * be treated as a local type. All constants ending in 131 * <code>FILE_TYPE</code> are used to indicate file types. 132 ***/ 133 public static final int LOCAL_FILE_TYPE = 3; 134 135 /*** 136 * A constant used for text files to indicate a non-print text format. 137 * This is the default format. 138 * All constants ending in <code>TEXT_FORMAT</code> are used to indicate 139 * text formatting for text transfers (both ASCII and EBCDIC). 140 ***/ 141 public static final int NON_PRINT_TEXT_FORMAT = 4; 142 143 /*** 144 * A constant used to indicate a text file contains format vertical format 145 * control characters. 146 * All constants ending in <code>TEXT_FORMAT</code> are used to indicate 147 * text formatting for text transfers (both ASCII and EBCDIC). 148 ***/ 149 public static final int TELNET_TEXT_FORMAT = 5; 150 151 /*** 152 * A constant used to indicate a text file contains ASA vertical format 153 * control characters. 154 * All constants ending in <code>TEXT_FORMAT</code> are used to indicate 155 * text formatting for text transfers (both ASCII and EBCDIC). 156 ***/ 157 public static final int CARRIAGE_CONTROL_TEXT_FORMAT = 6; 158 159 /*** 160 * A constant used to indicate a file is to be treated as a continuous 161 * sequence of bytes. This is the default structure. All constants ending 162 * in <code>_STRUCTURE</code> are used to indicate file structure for 163 * file transfers. 164 ***/ 165 public static final int FILE_STRUCTURE = 7; 166 167 /*** 168 * A constant used to indicate a file is to be treated as a sequence 169 * of records. All constants ending in <code>_STRUCTURE</code> 170 * are used to indicate file structure for file transfers. 171 ***/ 172 public static final int RECORD_STRUCTURE = 8; 173 174 /*** 175 * A constant used to indicate a file is to be treated as a set of 176 * independent indexed pages. All constants ending in 177 * <code>_STRUCTURE</code> are used to indicate file structure for file 178 * transfers. 179 ***/ 180 public static final int PAGE_STRUCTURE = 9; 181 182 /*** 183 * A constant used to indicate a file is to be transfered as a stream 184 * of bytes. This is the default transfer mode. All constants ending 185 * in <code>TRANSFER_MODE</code> are used to indicate file transfer 186 * modes. 187 ***/ 188 public static final int STREAM_TRANSFER_MODE = 10; 189 190 /*** 191 * A constant used to indicate a file is to be transfered as a series 192 * of blocks. All constants ending in <code>TRANSFER_MODE</code> are used 193 * to indicate file transfer modes. 194 ***/ 195 public static final int BLOCK_TRANSFER_MODE = 11; 196 197 /*** 198 * A constant used to indicate a file is to be transfered as FTP 199 * compressed data. All constants ending in <code>TRANSFER_MODE</code> 200 * are used to indicate file transfer modes. 201 ***/ 202 public static final int COMPRESSED_TRANSFER_MODE = 12; 203 204 // We have to ensure that the protocol communication is in ASCII 205 // but we use ISO-8859-1 just in case 8-bit characters cross 206 // the wire. 207 /** 208 * The default character encoding used for communicating over an 209 * FTP control connection. The default encoding is an 210 * ASCII-compatible encoding. Some FTP servers expect other 211 * encodings. You can change the encoding used by an FTP instance 212 * with {@link #setControlEncoding setControlEncoding}. 213 */ 214 public static final String DEFAULT_CONTROL_ENCODING = "ISO-8859-1"; 215 216 /** Length of the FTP reply code (3 alphanumerics) */ 217 public static final int REPLY_CODE_LEN = 3; 218 219 private static final String __modes = "AEILNTCFRPSBC"; 220 221 protected int _replyCode; 222 protected ArrayList<String> _replyLines; 223 protected boolean _newReplyString; 224 protected String _replyString; 225 protected String _controlEncoding; 226 227 /** 228 * A ProtocolCommandSupport object used to manage the registering of 229 * ProtocolCommandListeners and te firing of ProtocolCommandEvents. 230 */ 231 protected ProtocolCommandSupport _commandSupport_; 232 233 /** 234 * This is used to signal whether a block of multiline responses beginning 235 * with xxx must be terminated by the same numeric code xxx 236 * See section 4.2 of RFC 959 for details. 237 */ 238 protected boolean strictMultilineParsing = false; 239 240 /** 241 * Wraps SocketClient._input_ to facilitate the reading of text 242 * from the FTP control connection. Do not access the control 243 * connection via SocketClient._input_. This member starts 244 * with a null value, is initialized in {@link #_connectAction_}, 245 * and set to null in {@link #disconnect}. 246 */ 247 protected BufferedReader _controlInput_; 248 249 /** 250 * Wraps SocketClient._output_ to facilitate the writing of text 251 * to the FTP control connection. Do not access the control 252 * connection via SocketClient._output_. This member starts 253 * with a null value, is initialized in {@link #_connectAction_}, 254 * and set to null in {@link #disconnect}. 255 */ 256 protected BufferedWriter _controlOutput_; 257 258 /*** 259 * The default FTP constructor. Sets the default port to 260 * <code>DEFAULT_PORT</code> and initializes internal data structures 261 * for saving FTP reply information. 262 ***/ 263 public FTP() 264 { 265 super(); 266 setDefaultPort(DEFAULT_PORT); 267 _replyLines = new ArrayList<String>(); 268 _newReplyString = false; 269 _replyString = null; 270 _controlEncoding = DEFAULT_CONTROL_ENCODING; 271 _commandSupport_ = new ProtocolCommandSupport(this); 272 } 273 274 // The RFC-compliant multiline termination check 275 private boolean __strictCheck(String line, String code) { 276 return (!(line.startsWith(code) && line.charAt(REPLY_CODE_LEN) == ' ')); 277 } 278 279 // The strict check is too strong a condition because of non-conforming ftp 280 // servers like ftp.funet.fi which sent 226 as the last line of a 281 // 426 multi-line reply in response to ls /. We relax the condition to 282 // test that the line starts with a digit rather than starting with 283 // the code. 284 private boolean __lenientCheck(String line) { 285 return (!(line.length() > REPLY_CODE_LEN&& line.charAt(REPLY_CODE_LEN) != '-' && 286 Character.isDigit(line.charAt(0)))); 287 } 288 289 /** 290 * Get the reply, and pass it to command listeners 291 */ 292 private void __getReply() throws IOException 293 { 294 __getReply(true); 295 } 296 297 /** 298 * Get the reply, but don't pass it to command listeners. 299 * Used for keep-alive processing only. 300 * @since 3.0 301 */ 302 protected void __getReplyNoReport() throws IOException 303 { 304 __getReply(false); 305 } 306 307 private void __getReply(boolean reportReply) throws IOException 308 { 309 int length; 310 311 _newReplyString = true; 312 _replyLines.clear(); 313 314 String line = _controlInput_.readLine(); 315 316 if (line == null) { 317 throw new FTPConnectionClosedException( 318 "Connection closed without indication."); 319 } 320 321 // In case we run into an anomaly we don't want fatal index exceptions 322 // to be thrown. 323 length = line.length(); 324 if (length < REPLY_CODE_LEN) { 325 throw new MalformedServerReplyException( 326 "Truncated server reply: " + line); 327 } 328 329 String code = null; 330 try 331 { 332 code = line.substring(0, REPLY_CODE_LEN); 333 _replyCode = Integer.parseInt(code); 334 } 335 catch (NumberFormatException e) 336 { 337 throw new MalformedServerReplyException( 338 "Could not parse response code.\nServer Reply: " + line); 339 } 340 341 _replyLines.add(line); 342 343 // Get extra lines if message continues. 344 if (length > REPLY_CODE_LEN && line.charAt(REPLY_CODE_LEN) == '-') 345 { 346 do 347 { 348 line = _controlInput_.readLine(); 349 350 if (line == null) { 351 throw new FTPConnectionClosedException( 352 "Connection closed without indication."); 353 } 354 355 _replyLines.add(line); 356 357 // The length() check handles problems that could arise from readLine() 358 // returning too soon after encountering a naked CR or some other 359 // anomaly. 360 } 361 while ( isStrictMultilineParsing() ? __strictCheck(line, code) : __lenientCheck(line)); 362 } 363 364 fireReplyReceived(_replyCode, getReplyString()); 365 366 if (_replyCode == FTPReply.SERVICE_NOT_AVAILABLE) { 367 throw new FTPConnectionClosedException("FTP response 421 received. Server closed connection."); 368 } 369 } 370 371 /** 372 * Initiates control connections and gets initial reply. 373 * Initializes {@link #_controlInput_} and {@link #_controlOutput_}. 374 */ 375 @Override 376 protected void _connectAction_() throws IOException 377 { 378 super._connectAction_(); // sets up _input_ and _output_ 379 _controlInput_ = 380 new CRLFLineReader(new InputStreamReader(_input_, getControlEncoding())); 381 _controlOutput_ = 382 new BufferedWriter(new OutputStreamWriter(_output_, getControlEncoding())); 383 if (connectTimeout > 0) { // NET-385 384 int original = _socket_.getSoTimeout(); 385 _socket_.setSoTimeout(connectTimeout); 386 try { 387 __getReply(); 388 // If we received code 120, we have to fetch completion reply. 389 if (FTPReply.isPositivePreliminary(_replyCode)) { 390 __getReply(); 391 } 392 } catch (SocketTimeoutException e) { 393 IOException ioe = new IOException("Timed out waiting for initial connect reply"); 394 ioe.initCause(e); 395 throw ioe; 396 } finally { 397 _socket_.setSoTimeout(original); 398 } 399 } else { 400 __getReply(); 401 // If we received code 120, we have to fetch completion reply. 402 if (FTPReply.isPositivePreliminary(_replyCode)) { 403 __getReply(); 404 } 405 } 406 } 407 408 409 /** 410 * Sets the character encoding used by the FTP control connection. 411 * Some FTP servers require that commands be issued in a non-ASCII 412 * encoding like UTF-8 so that filenames with multi-byte character 413 * representations (e.g, Big 8) can be specified. 414 * 415 * @param encoding The new character encoding for the control connection. 416 */ 417 public void setControlEncoding(String encoding) { 418 _controlEncoding = encoding; 419 } 420 421 422 /** 423 * @return The character encoding used to communicate over the 424 * control connection. 425 */ 426 public String getControlEncoding() { 427 return _controlEncoding; 428 } 429 430 431 /*** 432 * Closes the control connection to the FTP server and sets to null 433 * some internal data so that the memory may be reclaimed by the 434 * garbage collector. The reply text and code information from the 435 * last command is voided so that the memory it used may be reclaimed. 436 * Also sets {@link #_controlInput_} and {@link #_controlOutput_} to null. 437 * <p> 438 * @exception IOException If an error occurs while disconnecting. 439 ***/ 440 @Override 441 public void disconnect() throws IOException 442 { 443 super.disconnect(); 444 _controlInput_ = null; 445 _controlOutput_ = null; 446 _newReplyString = false; 447 _replyString = null; 448 } 449 450 451 /*** 452 * Sends an FTP command to the server, waits for a reply and returns the 453 * numerical response code. After invocation, for more detailed 454 * information, the actual reply text can be accessed by calling 455 * {@link #getReplyString getReplyString } or 456 * {@link #getReplyStrings getReplyStrings }. 457 * <p> 458 * @param command The text representation of the FTP command to send. 459 * @param args The arguments to the FTP command. If this parameter is 460 * set to null, then the command is sent with no argument. 461 * @return The integer value of the FTP reply code returned by the server 462 * in response to the command. 463 * @exception FTPConnectionClosedException 464 * If the FTP server prematurely closes the connection as a result 465 * of the client being idle or some other reason causing the server 466 * to send FTP reply code 421. This exception may be caught either 467 * as an IOException or independently as itself. 468 * @exception IOException If an I/O error occurs while either sending the 469 * command or receiving the server reply. 470 ***/ 471 public int sendCommand(String command, String args) throws IOException 472 { 473 if (_controlOutput_ == null) { 474 throw new IOException("Connection is not open"); 475 } 476 477 final String message = __buildMessage(command, args); 478 479 __send(message); 480 481 fireCommandSent(command, message); 482 483 __getReply(); 484 return _replyCode; 485 } 486 487 private String __buildMessage(String command, String args) { 488 final StringBuilder __commandBuffer = new StringBuilder(); 489 490 __commandBuffer.append(command); 491 492 if (args != null) 493 { 494 __commandBuffer.append(' '); 495 __commandBuffer.append(args); 496 } 497 __commandBuffer.append(SocketClient.NETASCII_EOL); 498 return __commandBuffer.toString(); 499 } 500 501 private void __send(String message) throws IOException, 502 FTPConnectionClosedException, SocketException { 503 try{ 504 _controlOutput_.write(message); 505 _controlOutput_.flush(); 506 } 507 catch (SocketException e) 508 { 509 if (!isConnected()) 510 { 511 throw new FTPConnectionClosedException("Connection unexpectedly closed."); 512 } 513 else 514 { 515 throw e; 516 } 517 } 518 } 519 520 /** 521 * Send a noop and get the reply without reporting to the command listener. 522 * Intended for use with keep-alive. 523 * 524 * @throws IOException 525 * @since 3.0 526 */ 527 protected void __noop() throws IOException { 528 String msg = __buildMessage(FTPCommand.getCommand(FTPCommand.NOOP), null); 529 __send(msg); 530 __getReplyNoReport(); // This may timeout 531 } 532 533 /*** 534 * Sends an FTP command to the server, waits for a reply and returns the 535 * numerical response code. After invocation, for more detailed 536 * information, the actual reply text can be accessed by calling 537 * {@link #getReplyString getReplyString } or 538 * {@link #getReplyStrings getReplyStrings }. 539 * <p> 540 * @param command The FTPCommand constant corresponding to the FTP command 541 * to send. 542 * @param args The arguments to the FTP command. If this parameter is 543 * set to null, then the command is sent with no argument. 544 * @return The integer value of the FTP reply code returned by the server 545 * in response to the command. 546 * @exception FTPConnectionClosedException 547 * If the FTP server prematurely closes the connection as a result 548 * of the client being idle or some other reason causing the server 549 * to send FTP reply code 421. This exception may be caught either 550 * as an IOException or independently as itself. 551 * @exception IOException If an I/O error occurs while either sending the 552 * command or receiving the server reply. 553 ***/ 554 public int sendCommand(int command, String args) throws IOException 555 { 556 return sendCommand(FTPCommand.getCommand(command), args); 557 } 558 559 560 /*** 561 * Sends an FTP command with no arguments to the server, waits for a 562 * reply and returns the numerical response code. After invocation, for 563 * more detailed information, the actual reply text can be accessed by 564 * calling {@link #getReplyString getReplyString } or 565 * {@link #getReplyStrings getReplyStrings }. 566 * <p> 567 * @param command The text representation of the FTP command to send. 568 * @return The integer value of the FTP reply code returned by the server 569 * in response to the command. 570 * @exception FTPConnectionClosedException 571 * If the FTP server prematurely closes the connection as a result 572 * of the client being idle or some other reason causing the server 573 * to send FTP reply code 421. This exception may be caught either 574 * as an IOException or independently as itself. 575 * @exception IOException If an I/O error occurs while either sending the 576 * command or receiving the server reply. 577 ***/ 578 public int sendCommand(String command) throws IOException 579 { 580 return sendCommand(command, null); 581 } 582 583 584 /*** 585 * Sends an FTP command with no arguments to the server, waits for a 586 * reply and returns the numerical response code. After invocation, for 587 * more detailed information, the actual reply text can be accessed by 588 * calling {@link #getReplyString getReplyString } or 589 * {@link #getReplyStrings getReplyStrings }. 590 * <p> 591 * @param command The FTPCommand constant corresponding to the FTP command 592 * to send. 593 * @return The integer value of the FTP reply code returned by the server 594 * in response to the command. 595 * @exception FTPConnectionClosedException 596 * If the FTP server prematurely closes the connection as a result 597 * of the client being idle or some other reason causing the server 598 * to send FTP reply code 421. This exception may be caught either 599 * as an IOException or independently as itself. 600 * @exception IOException If an I/O error occurs while either sending the 601 * command or receiving the server reply. 602 ***/ 603 public int sendCommand(int command) throws IOException 604 { 605 return sendCommand(command, null); 606 } 607 608 609 /*** 610 * Returns the integer value of the reply code of the last FTP reply. 611 * You will usually only use this method after you connect to the 612 * FTP server to check that the connection was successful since 613 * <code> connect </code> is of type void. 614 * <p> 615 * @return The integer value of the reply code of the last FTP reply. 616 ***/ 617 public int getReplyCode() 618 { 619 return _replyCode; 620 } 621 622 /*** 623 * Fetches a reply from the FTP server and returns the integer reply 624 * code. After calling this method, the actual reply text can be accessed 625 * from either calling {@link #getReplyString getReplyString } or 626 * {@link #getReplyStrings getReplyStrings }. Only use this 627 * method if you are implementing your own FTP client or if you need to 628 * fetch a secondary response from the FTP server. 629 * <p> 630 * @return The integer value of the reply code of the fetched FTP reply. 631 * @exception FTPConnectionClosedException 632 * If the FTP server prematurely closes the connection as a result 633 * of the client being idle or some other reason causing the server 634 * to send FTP reply code 421. This exception may be caught either 635 * as an IOException or independently as itself. 636 * @exception IOException If an I/O error occurs while receiving the 637 * server reply. 638 ***/ 639 public int getReply() throws IOException 640 { 641 __getReply(); 642 return _replyCode; 643 } 644 645 646 /*** 647 * Returns the lines of text from the last FTP server response as an array 648 * of strings, one entry per line. The end of line markers of each are 649 * stripped from each line. 650 * <p> 651 * @return The lines of text from the last FTP response as an array. 652 ***/ 653 public String[] getReplyStrings() 654 { 655 return _replyLines.toArray(new String[_replyLines.size()]); 656 } 657 658 /*** 659 * Returns the entire text of the last FTP server response exactly 660 * as it was received, including all end of line markers in NETASCII 661 * format. 662 * <p> 663 * @return The entire text from the last FTP response as a String. 664 ***/ 665 public String getReplyString() 666 { 667 StringBuilder buffer; 668 669 if (!_newReplyString) { 670 return _replyString; 671 } 672 673 buffer = new StringBuilder(256); 674 675 for (String line : _replyLines) { 676 buffer.append(line); 677 buffer.append(SocketClient.NETASCII_EOL); 678 } 679 680 _newReplyString = false; 681 682 return (_replyString = buffer.toString()); 683 } 684 685 686 /*** 687 * A convenience method to send the FTP USER command to the server, 688 * receive the reply, and return the reply code. 689 * <p> 690 * @param username The username to login under. 691 * @return The reply code received from the server. 692 * @exception FTPConnectionClosedException 693 * If the FTP server prematurely closes the connection as a result 694 * of the client being idle or some other reason causing the server 695 * to send FTP reply code 421. This exception may be caught either 696 * as an IOException or independently as itself. 697 * @exception IOException If an I/O error occurs while either sending the 698 * command or receiving the server reply. 699 ***/ 700 public int user(String username) throws IOException 701 { 702 return sendCommand(FTPCommand.USER, username); 703 } 704 705 /** 706 * A convenience method to send the FTP PASS command to the server, 707 * receive the reply, and return the reply code. 708 * @param password The plain text password of the username being logged into. 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 pass(String password) throws IOException 719 { 720 return sendCommand(FTPCommand.PASS, password); 721 } 722 723 /*** 724 * A convenience method to send the FTP ACCT command to the server, 725 * receive the reply, and return the reply code. 726 * <p> 727 * @param account The account name to access. 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 acct(String account) throws IOException 738 { 739 return sendCommand(FTPCommand.ACCT, account); 740 } 741 742 743 /*** 744 * A convenience method to send the FTP ABOR command to the server, 745 * receive the reply, and return the reply code. 746 * <p> 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 abor() throws IOException 757 { 758 return sendCommand(FTPCommand.ABOR); 759 } 760 761 /*** 762 * A convenience method to send the FTP CWD command to the server, 763 * receive the reply, and return the reply code. 764 * <p> 765 * @param directory The new working directory. 766 * @return The reply code received from the server. 767 * @exception FTPConnectionClosedException 768 * If the FTP server prematurely closes the connection as a result 769 * of the client being idle or some other reason causing the server 770 * to send FTP reply code 421. This exception may be caught either 771 * as an IOException or independently as itself. 772 * @exception IOException If an I/O error occurs while either sending the 773 * command or receiving the server reply. 774 ***/ 775 public int cwd(String directory) throws IOException 776 { 777 return sendCommand(FTPCommand.CWD, directory); 778 } 779 780 /*** 781 * A convenience method to send the FTP CDUP command to the server, 782 * receive the reply, and return the reply code. 783 * <p> 784 * @return The reply code received from the server. 785 * @exception FTPConnectionClosedException 786 * If the FTP server prematurely closes the connection as a result 787 * of the client being idle or some other reason causing the server 788 * to send FTP reply code 421. This exception may be caught either 789 * as an IOException or independently as itself. 790 * @exception IOException If an I/O error occurs while either sending the 791 * command or receiving the server reply. 792 ***/ 793 public int cdup() throws IOException 794 { 795 return sendCommand(FTPCommand.CDUP); 796 } 797 798 /*** 799 * A convenience method to send the FTP QUIT command to the server, 800 * receive the reply, and return the reply code. 801 * <p> 802 * @return The reply code received from the server. 803 * @exception FTPConnectionClosedException 804 * If the FTP server prematurely closes the connection as a result 805 * of the client being idle or some other reason causing the server 806 * to send FTP reply code 421. This exception may be caught either 807 * as an IOException or independently as itself. 808 * @exception IOException If an I/O error occurs while either sending the 809 * command or receiving the server reply. 810 ***/ 811 public int quit() throws IOException 812 { 813 return sendCommand(FTPCommand.QUIT); 814 } 815 816 /*** 817 * A convenience method to send the FTP REIN command to the server, 818 * receive the reply, and return the reply code. 819 * <p> 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 rein() throws IOException 830 { 831 return sendCommand(FTPCommand.REIN); 832 } 833 834 /*** 835 * A convenience method to send the FTP SMNT command to the server, 836 * receive the reply, and return the reply code. 837 * <p> 838 * @param dir The directory name. 839 * @return The reply code received from the server. 840 * @exception FTPConnectionClosedException 841 * If the FTP server prematurely closes the connection as a result 842 * of the client being idle or some other reason causing the server 843 * to send FTP reply code 421. This exception may be caught either 844 * as an IOException or independently as itself. 845 * @exception IOException If an I/O error occurs while either sending the 846 * command or receiving the server reply. 847 ***/ 848 public int smnt(String dir) throws IOException 849 { 850 return sendCommand(FTPCommand.SMNT, dir); 851 } 852 853 /*** 854 * A convenience method to send the FTP PORT command to the server, 855 * receive the reply, and return the reply code. 856 * <p> 857 * @param host The host owning the port. 858 * @param port The new port. 859 * @return The reply code received from the server. 860 * @exception FTPConnectionClosedException 861 * If the FTP server prematurely closes the connection as a result 862 * of the client being idle or some other reason causing the server 863 * to send FTP reply code 421. This exception may be caught either 864 * as an IOException or independently as itself. 865 * @exception IOException If an I/O error occurs while either sending the 866 * command or receiving the server reply. 867 ***/ 868 public int port(InetAddress host, int port) throws IOException 869 { 870 int num; 871 StringBuilder info = new StringBuilder(24); 872 873 info.append(host.getHostAddress().replace('.', ',')); 874 num = port >>> 8; 875 info.append(','); 876 info.append(num); 877 info.append(','); 878 num = port & 0xff; 879 info.append(num); 880 881 return sendCommand(FTPCommand.PORT, info.toString()); 882 } 883 884 /*** 885 * A convenience method to send the FTP EPRT command to the server, 886 * receive the reply, and return the reply code. 887 * 888 * Examples: 889 * <code> 890 * <ul> 891 * <li>EPRT |1|132.235.1.2|6275|</li> 892 * <li>EPRT |2|1080::8:800:200C:417A|5282|</li> 893 * </ul> 894 * </code> 895 * <p> 896 * @see "http://www.faqs.org/rfcs/rfc2428.html" 897 * 898 * @param host The host owning the port. 899 * @param port The new port. 900 * @return The reply code received from the server. 901 * @exception FTPConnectionClosedException 902 * If the FTP server prematurely closes the connection as a result 903 * of the client being idle or some other reason causing the server 904 * to send FTP reply code 421. This exception may be caught either 905 * as an IOException or independently as itself. 906 * @exception IOException If an I/O error occurs while either sending the 907 * command or receiving the server reply. 908 * @since 2.2 909 ***/ 910 public int eprt(InetAddress host, int port) throws IOException 911 { 912 int num; 913 StringBuilder info = new StringBuilder(); 914 String h; 915 916 // If IPv6, trim the zone index 917 h = host.getHostAddress(); 918 num = h.indexOf("%"); 919 if (num > 0) { 920 h = h.substring(0, num); 921 } 922 923 info.append("|"); 924 925 if (host instanceof Inet4Address) { 926 info.append("1"); 927 } else if (host instanceof Inet6Address) { 928 info.append("2"); 929 } 930 info.append("|"); 931 info.append(h); 932 info.append("|"); 933 info.append(port); 934 info.append("|"); 935 936 return sendCommand(FTPCommand.EPRT, info.toString()); 937 } 938 939 /*** 940 * A convenience method to send the FTP PASV command to the server, 941 * receive the reply, and return the reply code. Remember, it's up 942 * to you to interpret the reply string containing the host/port 943 * information. 944 * <p> 945 * @return The reply code received from the server. 946 * @exception FTPConnectionClosedException 947 * If the FTP server prematurely closes the connection as a result 948 * of the client being idle or some other reason causing the server 949 * to send FTP reply code 421. This exception may be caught either 950 * as an IOException or independently as itself. 951 * @exception IOException If an I/O error occurs while either sending the 952 * command or receiving the server reply. 953 ***/ 954 public int pasv() throws IOException 955 { 956 return sendCommand(FTPCommand.PASV); 957 } 958 959 /*** 960 * A convenience method to send the FTP EPSV command to the server, 961 * receive the reply, and return the reply code. Remember, it's up 962 * to you to interpret the reply string containing the host/port 963 * information. 964 * <p> 965 * @return The reply code received from the server. 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 the 972 * command or receiving the server reply. 973 * @since 2.2 974 ***/ 975 public int epsv() throws IOException 976 { 977 return sendCommand(FTPCommand.EPSV); 978 } 979 980 /** 981 * A convenience method to send the FTP TYPE command for text files 982 * to the server, receive the reply, and return the reply code. 983 * @param fileType The type of the file (one of the <code>FILE_TYPE</code> 984 * constants). 985 * @param formatOrByteSize The format of the file (one of the 986 * <code>_FORMAT</code> constants. In the case of 987 * <code>LOCAL_FILE_TYPE</code>, the byte size. 988 * @return The reply code received from the server. 989 * @exception FTPConnectionClosedException 990 * If the FTP server prematurely closes the connection as a result 991 * of the client being idle or some other reason causing the server 992 * to send FTP reply code 421. This exception may be caught either 993 * as an IOException or independently as itself. 994 * @exception IOException If an I/O error occurs while either sending the 995 * command or receiving the server reply. 996 */ 997 public int type(int fileType, int formatOrByteSize) throws IOException 998 { 999 StringBuilder arg = new StringBuilder(); 1000 1001 arg.append(__modes.charAt(fileType)); 1002 arg.append(' '); 1003 if (fileType == LOCAL_FILE_TYPE) { 1004 arg.append(formatOrByteSize); 1005 } else { 1006 arg.append(__modes.charAt(formatOrByteSize)); 1007 } 1008 1009 return sendCommand(FTPCommand.TYPE, arg.toString()); 1010 } 1011 1012 1013 /** 1014 * A convenience method to send the FTP TYPE command to the server, 1015 * receive the reply, and return the reply code. 1016 * <p> 1017 * @param fileType The type of the file (one of the <code>FILE_TYPE</code> 1018 * constants). 1019 * @return The reply code received from the server. 1020 * @exception FTPConnectionClosedException 1021 * If the FTP server prematurely closes the connection as a result 1022 * of the client being idle or some other reason causing the server 1023 * to send FTP reply code 421. This exception may be caught either 1024 * as an IOException or independently as itself. 1025 * @exception IOException If an I/O error occurs while either sending the 1026 * command or receiving the server reply. 1027 */ 1028 public int type(int fileType) throws IOException 1029 { 1030 return sendCommand(FTPCommand.TYPE, 1031 __modes.substring(fileType, fileType + 1)); 1032 } 1033 1034 /*** 1035 * A convenience method to send the FTP STRU command to the server, 1036 * receive the reply, and return the reply code. 1037 * <p> 1038 * @param structure The structure of the file (one of the 1039 * <code>_STRUCTURE</code> constants). 1040 * @return The reply code received from the server. 1041 * @exception FTPConnectionClosedException 1042 * If the FTP server prematurely closes the connection as a result 1043 * of the client being idle or some other reason causing the server 1044 * to send FTP reply code 421. This exception may be caught either 1045 * as an IOException or independently as itself. 1046 * @exception IOException If an I/O error occurs while either sending the 1047 * command or receiving the server reply. 1048 ***/ 1049 public int stru(int structure) throws IOException 1050 { 1051 return sendCommand(FTPCommand.STRU, 1052 __modes.substring(structure, structure + 1)); 1053 } 1054 1055 /*** 1056 * A convenience method to send the FTP MODE command to the server, 1057 * receive the reply, and return the reply code. 1058 * <p> 1059 * @param mode The transfer mode to use (one of the 1060 * <code>TRANSFER_MODE</code> constants). 1061 * @return The reply code received from the server. 1062 * @exception FTPConnectionClosedException 1063 * If the FTP server prematurely closes the connection as a result 1064 * of the client being idle or some other reason causing the server 1065 * to send FTP reply code 421. This exception may be caught either 1066 * as an IOException or independently as itself. 1067 * @exception IOException If an I/O error occurs while either sending the 1068 * command or receiving the server reply. 1069 ***/ 1070 public int mode(int mode) throws IOException 1071 { 1072 return sendCommand(FTPCommand.MODE, 1073 __modes.substring(mode, mode + 1)); 1074 } 1075 1076 /*** 1077 * A convenience method to send the FTP RETR 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 of the file to retrieve. 1084 * @return The reply code received from the server. 1085 * @exception FTPConnectionClosedException 1086 * If the FTP server prematurely closes the connection as a result 1087 * of the client being idle or some other reason causing the server 1088 * to send FTP reply code 421. This exception may be caught either 1089 * as an IOException or independently as itself. 1090 * @exception IOException If an I/O error occurs while either sending the 1091 * command or receiving the server reply. 1092 ***/ 1093 public int retr(String pathname) throws IOException 1094 { 1095 return sendCommand(FTPCommand.RETR, pathname); 1096 } 1097 1098 /*** 1099 * A convenience method to send the FTP STOR command to the server, 1100 * receive the reply, and return the reply code. Remember, it is up 1101 * to you to manage the data connection. If you don't need this low 1102 * level of access, use {@link org.apache.commons.net.ftp.FTPClient} 1103 * , which will handle all low level details for you. 1104 * <p> 1105 * @param pathname The pathname to use for the file when stored at 1106 * the remote end of the transfer. 1107 * @return The reply code received from the server. 1108 * @exception FTPConnectionClosedException 1109 * If the FTP server prematurely closes the connection as a result 1110 * of the client being idle or some other reason causing the server 1111 * to send FTP reply code 421. This exception may be caught either 1112 * as an IOException or independently as itself. 1113 * @exception IOException If an I/O error occurs while either sending the 1114 * command or receiving the server reply. 1115 ***/ 1116 public int stor(String pathname) throws IOException 1117 { 1118 return sendCommand(FTPCommand.STOR, pathname); 1119 } 1120 1121 /*** 1122 * A convenience method to send the FTP STOU command to the server, 1123 * receive the reply, and return the reply code. Remember, it is up 1124 * to you to manage the data connection. If you don't need this low 1125 * level of access, use {@link org.apache.commons.net.ftp.FTPClient} 1126 * , which will handle all low level details for you. 1127 * <p> 1128 * @return The reply code received from the server. 1129 * @exception FTPConnectionClosedException 1130 * If the FTP server prematurely closes the connection as a result 1131 * of the client being idle or some other reason causing the server 1132 * to send FTP reply code 421. This exception may be caught either 1133 * as an IOException or independently as itself. 1134 * @exception IOException If an I/O error occurs while either sending the 1135 * command or receiving the server reply. 1136 ***/ 1137 public int stou() throws IOException 1138 { 1139 return sendCommand(FTPCommand.STOU); 1140 } 1141 1142 /*** 1143 * A convenience method to send the FTP STOU command to the server, 1144 * receive the reply, and return the reply code. Remember, it is up 1145 * to you to manage the data connection. If you don't need this low 1146 * level of access, use {@link org.apache.commons.net.ftp.FTPClient} 1147 * , which will handle all low level details for you. 1148 * @param pathname The base pathname to use for the file when stored at 1149 * the remote end of the transfer. Some FTP servers 1150 * require this. 1151 * @return The reply code received from the server. 1152 * @exception FTPConnectionClosedException 1153 * If the FTP server prematurely closes the connection as a result 1154 * of the client being idle or some other reason causing the server 1155 * to send FTP reply code 421. This exception may be caught either 1156 * as an IOException or independently as itself. 1157 * @exception IOException If an I/O error occurs while either sending the 1158 * command or receiving the server reply. 1159 */ 1160 public int stou(String pathname) throws IOException 1161 { 1162 return sendCommand(FTPCommand.STOU, pathname); 1163 } 1164 1165 /*** 1166 * A convenience method to send the FTP APPE command to the server, 1167 * receive the reply, and return the reply code. Remember, it is up 1168 * to you to manage the data connection. If you don't need this low 1169 * level of access, use {@link org.apache.commons.net.ftp.FTPClient} 1170 * , which will handle all low level details for you. 1171 * <p> 1172 * @param pathname The pathname to use for the file when stored at 1173 * the remote end of the transfer. 1174 * @return The reply code received from the server. 1175 * @exception FTPConnectionClosedException 1176 * If the FTP server prematurely closes the connection as a result 1177 * of the client being idle or some other reason causing the server 1178 * to send FTP reply code 421. This exception may be caught either 1179 * as an IOException or independently as itself. 1180 * @exception IOException If an I/O error occurs while either sending the 1181 * command or receiving the server reply. 1182 ***/ 1183 public int appe(String pathname) throws IOException 1184 { 1185 return sendCommand(FTPCommand.APPE, pathname); 1186 } 1187 1188 /*** 1189 * A convenience method to send the FTP ALLO command to the server, 1190 * receive the reply, and return the reply code. 1191 * <p> 1192 * @param bytes The number of bytes to allocate. 1193 * @return The reply code received from the server. 1194 * @exception FTPConnectionClosedException 1195 * If the FTP server prematurely closes the connection as a result 1196 * of the client being idle or some other reason causing the server 1197 * to send FTP reply code 421. This exception may be caught either 1198 * as an IOException or independently as itself. 1199 * @exception IOException If an I/O error occurs while either sending the 1200 * command or receiving the server reply. 1201 ***/ 1202 public int allo(int bytes) throws IOException 1203 { 1204 return sendCommand(FTPCommand.ALLO, Integer.toString(bytes)); 1205 } 1206 1207 /** 1208 * A convenience method to send the FTP FEAT command to the server, receive the reply, 1209 * and return the reply code. 1210 * @return The reply code received by the server 1211 * @throws IOException If an I/O error occurs while either sending the 1212 * command or receiving the server reply. 1213 * @since 2.2 1214 */ 1215 public int feat() throws IOException 1216 { 1217 return sendCommand(FTPCommand.FEAT); 1218 } 1219 1220 /*** 1221 * A convenience method to send the FTP ALLO command to the server, 1222 * receive the reply, and return the reply code. 1223 * <p> 1224 * @param bytes The number of bytes to allocate. 1225 * @param recordSize The size of a record. 1226 * @return The reply code received from the server. 1227 * @exception FTPConnectionClosedException 1228 * If the FTP server prematurely closes the connection as a result 1229 * of the client being idle or some other reason causing the server 1230 * to send FTP reply code 421. This exception may be caught either 1231 * as an IOException or independently as itself. 1232 * @exception IOException If an I/O error occurs while either sending the 1233 * command or receiving the server reply. 1234 ***/ 1235 public int allo(int bytes, int recordSize) throws IOException 1236 { 1237 return sendCommand(FTPCommand.ALLO, Integer.toString(bytes) + " R " + 1238 Integer.toString(recordSize)); 1239 } 1240 1241 /*** 1242 * A convenience method to send the FTP REST command to the server, 1243 * receive the reply, and return the reply code. 1244 * <p> 1245 * @param marker The marker at which to restart a transfer. 1246 * @return The reply code received from the server. 1247 * @exception FTPConnectionClosedException 1248 * If the FTP server prematurely closes the connection as a result 1249 * of the client being idle or some other reason causing the server 1250 * to send FTP reply code 421. This exception may be caught either 1251 * as an IOException or independently as itself. 1252 * @exception IOException If an I/O error occurs while either sending the 1253 * command or receiving the server reply. 1254 ***/ 1255 public int rest(String marker) throws IOException 1256 { 1257 return sendCommand(FTPCommand.REST, marker); 1258 } 1259 1260 1261 /** 1262 * @since 2.0 1263 **/ 1264 public int mdtm(String file) throws IOException 1265 { 1266 return sendCommand(FTPCommand.MDTM, file); 1267 } 1268 1269 1270 /** 1271 * A convenience method to send the FTP MFMT command to the server, 1272 * receive the reply, and return the reply code. 1273 * <p> 1274 * @param pathname The pathname for which mtime is to be changed 1275 * @param timeval Timestamp in <code>YYYYMMDDhhmmss</code> format 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 * @since 2.2 1285 * @see <a href="http://tools.ietf.org/html/draft-somers-ftp-mfxx-04">http://tools.ietf.org/html/draft-somers-ftp-mfxx-04</a> 1286 **/ 1287 public int mfmt(String pathname, String timeval) throws IOException 1288 { 1289 return sendCommand(FTPCommand.MFMT, timeval + " " + pathname); 1290 } 1291 1292 1293 /*** 1294 * A convenience method to send the FTP RNFR command to the server, 1295 * receive the reply, and return the reply code. 1296 * <p> 1297 * @param pathname The pathname to rename from. 1298 * @return The reply code received from the server. 1299 * @exception FTPConnectionClosedException 1300 * If the FTP server prematurely closes the connection as a result 1301 * of the client being idle or some other reason causing the server 1302 * to send FTP reply code 421. This exception may be caught either 1303 * as an IOException or independently as itself. 1304 * @exception IOException If an I/O error occurs while either sending the 1305 * command or receiving the server reply. 1306 ***/ 1307 public int rnfr(String pathname) throws IOException 1308 { 1309 return sendCommand(FTPCommand.RNFR, pathname); 1310 } 1311 1312 /*** 1313 * A convenience method to send the FTP RNTO command to the server, 1314 * receive the reply, and return the reply code. 1315 * <p> 1316 * @param pathname The pathname to rename to 1317 * @return The reply code received from the server. 1318 * @exception FTPConnectionClosedException 1319 * If the FTP server prematurely closes the connection as a result 1320 * of the client being idle or some other reason causing the server 1321 * to send FTP reply code 421. This exception may be caught either 1322 * as an IOException or independently as itself. 1323 * @exception IOException If an I/O error occurs while either sending the 1324 * command or receiving the server reply. 1325 ***/ 1326 public int rnto(String pathname) throws IOException 1327 { 1328 return sendCommand(FTPCommand.RNTO, pathname); 1329 } 1330 1331 /*** 1332 * A convenience method to send the FTP DELE command to the server, 1333 * receive the reply, and return the reply code. 1334 * <p> 1335 * @param pathname The pathname to delete. 1336 * @return The reply code received from the server. 1337 * @exception FTPConnectionClosedException 1338 * If the FTP server prematurely closes the connection as a result 1339 * of the client being idle or some other reason causing the server 1340 * to send FTP reply code 421. This exception may be caught either 1341 * as an IOException or independently as itself. 1342 * @exception IOException If an I/O error occurs while either sending the 1343 * command or receiving the server reply. 1344 ***/ 1345 public int dele(String pathname) throws IOException 1346 { 1347 return sendCommand(FTPCommand.DELE, pathname); 1348 } 1349 1350 /*** 1351 * A convenience method to send the FTP RMD command to the server, 1352 * receive the reply, and return the reply code. 1353 * <p> 1354 * @param pathname The pathname of the directory to remove. 1355 * @return The reply code received from the server. 1356 * @exception FTPConnectionClosedException 1357 * If the FTP server prematurely closes the connection as a result 1358 * of the client being idle or some other reason causing the server 1359 * to send FTP reply code 421. This exception may be caught either 1360 * as an IOException or independently as itself. 1361 * @exception IOException If an I/O error occurs while either sending the 1362 * command or receiving the server reply. 1363 ***/ 1364 public int rmd(String pathname) throws IOException 1365 { 1366 return sendCommand(FTPCommand.RMD, pathname); 1367 } 1368 1369 /*** 1370 * A convenience method to send the FTP MKD command to the server, 1371 * receive the reply, and return the reply code. 1372 * <p> 1373 * @param pathname The pathname of the new directory to create. 1374 * @return The reply code received from the server. 1375 * @exception FTPConnectionClosedException 1376 * If the FTP server prematurely closes the connection as a result 1377 * of the client being idle or some other reason causing the server 1378 * to send FTP reply code 421. This exception may be caught either 1379 * as an IOException or independently as itself. 1380 * @exception IOException If an I/O error occurs while either sending the 1381 * command or receiving the server reply. 1382 ***/ 1383 public int mkd(String pathname) throws IOException 1384 { 1385 return sendCommand(FTPCommand.MKD, pathname); 1386 } 1387 1388 /*** 1389 * A convenience method to send the FTP PWD command to the server, 1390 * receive the reply, and return the reply code. 1391 * <p> 1392 * @return The reply code received from the server. 1393 * @exception FTPConnectionClosedException 1394 * If the FTP server prematurely closes the connection as a result 1395 * of the client being idle or some other reason causing the server 1396 * to send FTP reply code 421. This exception may be caught either 1397 * as an IOException or independently as itself. 1398 * @exception IOException If an I/O error occurs while either sending the 1399 * command or receiving the server reply. 1400 ***/ 1401 public int pwd() throws IOException 1402 { 1403 return sendCommand(FTPCommand.PWD); 1404 } 1405 1406 /*** 1407 * A convenience method to send the FTP LIST command to the server, 1408 * receive the reply, and return the reply code. Remember, it is up 1409 * to you to manage the data connection. If you don't need this low 1410 * level of access, use {@link org.apache.commons.net.ftp.FTPClient} 1411 * , which will handle all low level details for you. 1412 * <p> 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() throws IOException 1423 { 1424 return sendCommand(FTPCommand.LIST); 1425 } 1426 1427 /*** 1428 * A convenience method to send the FTP LIST 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 * @param pathname The pathname to list, 1435 * may be {@code null} in which case the command is sent with no parameters 1436 * @return The reply code received from the server. 1437 * @exception FTPConnectionClosedException 1438 * If the FTP server prematurely closes the connection as a result 1439 * of the client being idle or some other reason causing the server 1440 * to send FTP reply code 421. This exception may be caught either 1441 * as an IOException or independently as itself. 1442 * @exception IOException If an I/O error occurs while either sending the 1443 * command or receiving the server reply. 1444 ***/ 1445 public int list(String pathname) throws IOException 1446 { 1447 return sendCommand(FTPCommand.LIST, pathname); 1448 } 1449 1450 /** 1451 * A convenience method to send the FTP MLSD command to the server, 1452 * receive the reply, and return the reply code. Remember, it is up 1453 * to you to manage the data connection. If you don't need this low 1454 * level of access, use {@link org.apache.commons.net.ftp.FTPClient} 1455 * , which will handle all low level details for you. 1456 * <p> 1457 * @return The reply code received from the server. 1458 * @exception FTPConnectionClosedException 1459 * If the FTP server prematurely closes the connection as a result 1460 * of the client being idle or some other reason causing the server 1461 * to send FTP reply code 421. This exception may be caught either 1462 * as an IOException or independently as itself. 1463 * @exception IOException If an I/O error occurs while either sending the 1464 * command or receiving the server reply. 1465 * @since 3.0 1466 */ 1467 public int mlsd() throws IOException 1468 { 1469 return sendCommand(FTPCommand.MLSD); 1470 } 1471 1472 /** 1473 * A convenience method to send the FTP MLSD command to the server, 1474 * receive the reply, and return the reply code. Remember, it is up 1475 * to you to manage the data connection. If you don't need this low 1476 * level of access, use {@link org.apache.commons.net.ftp.FTPClient} 1477 * , which will handle all low level details for you. 1478 * <p> 1479 * @param path the path to report on 1480 * @return The reply code received from the server, 1481 * may be {@code null} in which case the command is sent with no parameters 1482 * @exception FTPConnectionClosedException 1483 * If the FTP server prematurely closes the connection as a result 1484 * of the client being idle or some other reason causing the server 1485 * to send FTP reply code 421. This exception may be caught either 1486 * as an IOException or independently as itself. 1487 * @exception IOException If an I/O error occurs while either sending the 1488 * command or receiving the server reply. 1489 * @since 3.0 1490 */ 1491 public int mlsd(String path) throws IOException 1492 { 1493 return sendCommand(FTPCommand.MLSD, path); 1494 } 1495 1496 /** 1497 * A convenience method to send the FTP MLST command to the server, 1498 * receive the reply, and return the reply code. Remember, it is up 1499 * to you to manage the data connection. If you don't need this low 1500 * level of access, use {@link org.apache.commons.net.ftp.FTPClient} 1501 * , which will handle all low level details for you. 1502 * <p> 1503 * @return The reply code received from the server. 1504 * @exception FTPConnectionClosedException 1505 * If the FTP server prematurely closes the connection as a result 1506 * of the client being idle or some other reason causing the server 1507 * to send FTP reply code 421. This exception may be caught either 1508 * as an IOException or independently as itself. 1509 * @exception IOException If an I/O error occurs while either sending the 1510 * command or receiving the server reply. 1511 * @since 3.0 1512 */ 1513 public int mlst() throws IOException 1514 { 1515 return sendCommand(FTPCommand.MLST); 1516 } 1517 1518 /** 1519 * A convenience method to send the FTP MLST command to the server, 1520 * receive the reply, and return the reply code. Remember, it is up 1521 * to you to manage the data connection. If you don't need this low 1522 * level of access, use {@link org.apache.commons.net.ftp.FTPClient} 1523 * , which will handle all low level details for you. 1524 * <p> 1525 * @param path the path to report on 1526 * @return The reply code received from the server, 1527 * may be {@code null} in which case the command is sent with no parameters 1528 * @exception FTPConnectionClosedException 1529 * If the FTP server prematurely closes the connection as a result 1530 * of the client being idle or some other reason causing the server 1531 * to send FTP reply code 421. This exception may be caught either 1532 * as an IOException or independently as itself. 1533 * @exception IOException If an I/O error occurs while either sending the 1534 * command or receiving the server reply. 1535 * @since 3.0 1536 */ 1537 public int mlst(String path) throws IOException 1538 { 1539 return sendCommand(FTPCommand.MLST, path); 1540 } 1541 1542 /*** 1543 * A convenience method to send the FTP NLST command to the server, 1544 * receive the reply, and return the reply code. Remember, it is up 1545 * to you to manage the data connection. If you don't need this low 1546 * level of access, use {@link org.apache.commons.net.ftp.FTPClient} 1547 * , which will handle all low level details for you. 1548 * <p> 1549 * @return The reply code received from the server. 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 the 1556 * command or receiving the server reply. 1557 ***/ 1558 public int nlst() throws IOException 1559 { 1560 return sendCommand(FTPCommand.NLST); 1561 } 1562 1563 /*** 1564 * A convenience method to send the FTP NLST command to the server, 1565 * receive the reply, and return the reply code. Remember, it is up 1566 * to you to manage the data connection. If you don't need this low 1567 * level of access, use {@link org.apache.commons.net.ftp.FTPClient} 1568 * , which will handle all low level details for you. 1569 * <p> 1570 * @param pathname The pathname to list, 1571 * may be {@code null} in which case the command is sent with no parameters 1572 * @return The reply code received from the server. 1573 * @exception FTPConnectionClosedException 1574 * If the FTP server prematurely closes the connection as a result 1575 * of the client being idle or some other reason causing the server 1576 * to send FTP reply code 421. This exception may be caught either 1577 * as an IOException or independently as itself. 1578 * @exception IOException If an I/O error occurs while either sending the 1579 * command or receiving the server reply. 1580 ***/ 1581 public int nlst(String pathname) throws IOException 1582 { 1583 return sendCommand(FTPCommand.NLST, pathname); 1584 } 1585 1586 /*** 1587 * A convenience method to send the FTP SITE command to the server, 1588 * receive the reply, and return the reply code. 1589 * <p> 1590 * @param parameters The site parameters to send. 1591 * @return The reply code received from the server. 1592 * @exception FTPConnectionClosedException 1593 * If the FTP server prematurely closes the connection as a result 1594 * of the client being idle or some other reason causing the server 1595 * to send FTP reply code 421. This exception may be caught either 1596 * as an IOException or independently as itself. 1597 * @exception IOException If an I/O error occurs while either sending the 1598 * command or receiving the server reply. 1599 ***/ 1600 public int site(String parameters) throws IOException 1601 { 1602 return sendCommand(FTPCommand.SITE, parameters); 1603 } 1604 1605 /*** 1606 * A convenience method to send the FTP SYST command to the server, 1607 * receive the reply, and return the reply code. 1608 * <p> 1609 * @return The reply code received from the server. 1610 * @exception FTPConnectionClosedException 1611 * If the FTP server prematurely closes the connection as a result 1612 * of the client being idle or some other reason causing the server 1613 * to send FTP reply code 421. This exception may be caught either 1614 * as an IOException or independently as itself. 1615 * @exception IOException If an I/O error occurs while either sending the 1616 * command or receiving the server reply. 1617 ***/ 1618 public int syst() throws IOException 1619 { 1620 return sendCommand(FTPCommand.SYST); 1621 } 1622 1623 /*** 1624 * A convenience method to send the FTP STAT command to the server, 1625 * receive the reply, and return the reply code. 1626 * <p> 1627 * @return The reply code received from the server. 1628 * @exception FTPConnectionClosedException 1629 * If the FTP server prematurely closes the connection as a result 1630 * of the client being idle or some other reason causing the server 1631 * to send FTP reply code 421. This exception may be caught either 1632 * as an IOException or independently as itself. 1633 * @exception IOException If an I/O error occurs while either sending the 1634 * command or receiving the server reply. 1635 ***/ 1636 public int stat() throws IOException 1637 { 1638 return sendCommand(FTPCommand.STAT); 1639 } 1640 1641 /*** 1642 * A convenience method to send the FTP STAT command to the server, 1643 * receive the reply, and return the reply code. 1644 * <p> 1645 * @param pathname A pathname to list. 1646 * @return The reply code received from the server. 1647 * @exception FTPConnectionClosedException 1648 * If the FTP server prematurely closes the connection as a result 1649 * of the client being idle or some other reason causing the server 1650 * to send FTP reply code 421. This exception may be caught either 1651 * as an IOException or independently as itself. 1652 * @exception IOException If an I/O error occurs while either sending the 1653 * command or receiving the server reply. 1654 ***/ 1655 public int stat(String pathname) throws IOException 1656 { 1657 return sendCommand(FTPCommand.STAT, pathname); 1658 } 1659 1660 /*** 1661 * A convenience method to send the FTP HELP command to the server, 1662 * receive the reply, and return the reply code. 1663 * <p> 1664 * @return The reply code received from the server. 1665 * @exception FTPConnectionClosedException 1666 * If the FTP server prematurely closes the connection as a result 1667 * of the client being idle or some other reason causing the server 1668 * to send FTP reply code 421. This exception may be caught either 1669 * as an IOException or independently as itself. 1670 * @exception IOException If an I/O error occurs while either sending the 1671 * command or receiving the server reply. 1672 ***/ 1673 public int help() throws IOException 1674 { 1675 return sendCommand(FTPCommand.HELP); 1676 } 1677 1678 /*** 1679 * A convenience method to send the FTP HELP command to the server, 1680 * receive the reply, and return the reply code. 1681 * <p> 1682 * @param command The command name on which to request help. 1683 * @return The reply code received from the server. 1684 * @exception FTPConnectionClosedException 1685 * If the FTP server prematurely closes the connection as a result 1686 * of the client being idle or some other reason causing the server 1687 * to send FTP reply code 421. This exception may be caught either 1688 * as an IOException or independently as itself. 1689 * @exception IOException If an I/O error occurs while either sending the 1690 * command or receiving the server reply. 1691 ***/ 1692 public int help(String command) throws IOException 1693 { 1694 return sendCommand(FTPCommand.HELP, command); 1695 } 1696 1697 /*** 1698 * A convenience method to send the FTP NOOP command to the server, 1699 * receive the reply, and return the reply code. 1700 * <p> 1701 * @return The reply code received from the server. 1702 * @exception FTPConnectionClosedException 1703 * If the FTP server prematurely closes the connection as a result 1704 * of the client being idle or some other reason causing the server 1705 * to send FTP reply code 421. This exception may be caught either 1706 * as an IOException or independently as itself. 1707 * @exception IOException If an I/O error occurs while either sending the 1708 * command or receiving the server reply. 1709 ***/ 1710 public int noop() throws IOException 1711 { 1712 return sendCommand(FTPCommand.NOOP); 1713 } 1714 1715 /** 1716 * Return whether strict multiline parsing is enabled, as per RFC 959, section 4.2. 1717 * @return True if strict, false if lenient 1718 * @since 2.0 1719 */ 1720 public boolean isStrictMultilineParsing() { 1721 return strictMultilineParsing; 1722 } 1723 1724 /** 1725 * Set strict multiline parsing. 1726 * @param strictMultilineParsing 1727 * @since 2.0 1728 */ 1729 public void setStrictMultilineParsing(boolean strictMultilineParsing) { 1730 this.strictMultilineParsing = strictMultilineParsing; 1731 } 1732 1733 /** 1734 * Provide command support to super-class 1735 */ 1736 @Override 1737 protected ProtocolCommandSupport getCommandSupport() { 1738 return _commandSupport_; 1739 } 1740 } 1741 1742 /* Emacs configuration 1743 * Local variables: ** 1744 * mode: java ** 1745 * c-basic-offset: 4 ** 1746 * indent-tabs-mode: nil ** 1747 * End: ** 1748 */