--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/java.base/share/classes/sun/net/ftp/impl/FtpClient.java Sun Aug 17 15:54:13 2014 +0100
@@ -0,0 +1,2211 @@
+/*
+ * Copyright (c) 2009, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package sun.net.ftp.impl;
+
+import java.net.*;
+import java.io.*;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.List;
+import java.util.TimeZone;
+import java.util.Vector;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+import sun.net.ftp.*;
+import sun.util.logging.PlatformLogger;
+
+
+public class FtpClient extends sun.net.ftp.FtpClient {
+
+ private static int defaultSoTimeout;
+ private static int defaultConnectTimeout;
+ private static final PlatformLogger logger =
+ PlatformLogger.getLogger("sun.net.ftp.FtpClient");
+ private Proxy proxy;
+ private Socket server;
+ private PrintStream out;
+ private InputStream in;
+ private int readTimeout = -1;
+ private int connectTimeout = -1;
+
+ /* Name of encoding to use for output */
+ private static String encoding = "ISO8859_1";
+ /** remember the ftp server name because we may need it */
+ private InetSocketAddress serverAddr;
+ private boolean replyPending = false;
+ private boolean loggedIn = false;
+ private boolean useCrypto = false;
+ private SSLSocketFactory sslFact;
+ private Socket oldSocket;
+ /** Array of strings (usually 1 entry) for the last reply from the server. */
+ private Vector<String> serverResponse = new Vector<String>(1);
+ /** The last reply code from the ftp daemon. */
+ private FtpReplyCode lastReplyCode = null;
+ /** Welcome message from the server, if any. */
+ private String welcomeMsg;
+ /**
+ * Only passive mode used in JDK. See Bug 8010784.
+ */
+ private final boolean passiveMode = true;
+ private TransferType type = TransferType.BINARY;
+ private long restartOffset = 0;
+ private long lastTransSize = -1; // -1 means 'unknown size'
+ private String lastFileName;
+ /**
+ * Static members used by the parser
+ */
+ private static String[] patStrings = {
+ // drwxr-xr-x 1 user01 ftp 512 Jan 29 23:32 prog
+ "([\\-ld](?:[r\\-][w\\-][x\\-]){3})\\s*\\d+ (\\w+)\\s*(\\w+)\\s*(\\d+)\\s*([A-Z][a-z][a-z]\\s*\\d+)\\s*(\\d\\d:\\d\\d)\\s*(\\p{Print}*)",
+ // drwxr-xr-x 1 user01 ftp 512 Jan 29 1997 prog
+ "([\\-ld](?:[r\\-][w\\-][x\\-]){3})\\s*\\d+ (\\w+)\\s*(\\w+)\\s*(\\d+)\\s*([A-Z][a-z][a-z]\\s*\\d+)\\s*(\\d{4})\\s*(\\p{Print}*)",
+ // 04/28/2006 09:12a 3,563 genBuffer.sh
+ "(\\d{2}/\\d{2}/\\d{4})\\s*(\\d{2}:\\d{2}[ap])\\s*((?:[0-9,]+)|(?:<DIR>))\\s*(\\p{Graph}*)",
+ // 01-29-97 11:32PM <DIR> prog
+ "(\\d{2}-\\d{2}-\\d{2})\\s*(\\d{2}:\\d{2}[AP]M)\\s*((?:[0-9,]+)|(?:<DIR>))\\s*(\\p{Graph}*)"
+ };
+ private static int[][] patternGroups = {
+ // 0 - file, 1 - size, 2 - date, 3 - time, 4 - year, 5 - permissions,
+ // 6 - user, 7 - group
+ {7, 4, 5, 6, 0, 1, 2, 3},
+ {7, 4, 5, 0, 6, 1, 2, 3},
+ {4, 3, 1, 2, 0, 0, 0, 0},
+ {4, 3, 1, 2, 0, 0, 0, 0}};
+ private static Pattern[] patterns;
+ private static Pattern linkp = Pattern.compile("(\\p{Print}+) \\-\\> (\\p{Print}+)$");
+ private DateFormat df = DateFormat.getDateInstance(DateFormat.MEDIUM, java.util.Locale.US);
+
+ static {
+ final int vals[] = {0, 0};
+ final String encs[] = {null};
+
+ AccessController.doPrivileged(
+ new PrivilegedAction<Object>() {
+
+ public Object run() {
+ vals[0] = Integer.getInteger("sun.net.client.defaultReadTimeout", 0).intValue();
+ vals[1] = Integer.getInteger("sun.net.client.defaultConnectTimeout", 0).intValue();
+ encs[0] = System.getProperty("file.encoding", "ISO8859_1");
+ return null;
+ }
+ });
+ if (vals[0] == 0) {
+ defaultSoTimeout = -1;
+ } else {
+ defaultSoTimeout = vals[0];
+ }
+
+ if (vals[1] == 0) {
+ defaultConnectTimeout = -1;
+ } else {
+ defaultConnectTimeout = vals[1];
+ }
+
+ encoding = encs[0];
+ try {
+ if (!isASCIISuperset(encoding)) {
+ encoding = "ISO8859_1";
+ }
+ } catch (Exception e) {
+ encoding = "ISO8859_1";
+ }
+
+ patterns = new Pattern[patStrings.length];
+ for (int i = 0; i < patStrings.length; i++) {
+ patterns[i] = Pattern.compile(patStrings[i]);
+ }
+ }
+
+ /**
+ * Test the named character encoding to verify that it converts ASCII
+ * characters correctly. We have to use an ASCII based encoding, or else
+ * the NetworkClients will not work correctly in EBCDIC based systems.
+ * However, we cannot just use ASCII or ISO8859_1 universally, because in
+ * Asian locales, non-ASCII characters may be embedded in otherwise
+ * ASCII based protocols (eg. HTTP). The specifications (RFC2616, 2398)
+ * are a little ambiguous in this matter. For instance, RFC2398 [part 2.1]
+ * says that the HTTP request URI should be escaped using a defined
+ * mechanism, but there is no way to specify in the escaped string what
+ * the original character set is. It is not correct to assume that
+ * UTF-8 is always used (as in URLs in HTML 4.0). For this reason,
+ * until the specifications are updated to deal with this issue more
+ * comprehensively, and more importantly, HTTP servers are known to
+ * support these mechanisms, we will maintain the current behavior
+ * where it is possible to send non-ASCII characters in their original
+ * unescaped form.
+ */
+ private static boolean isASCIISuperset(String encoding) throws Exception {
+ String chkS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" +
+ "abcdefghijklmnopqrstuvwxyz-_.!~*'();/?:@&=+$,";
+
+ // Expected byte sequence for string above
+ byte[] chkB = {48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72,
+ 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98, 99,
+ 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
+ 115, 116, 117, 118, 119, 120, 121, 122, 45, 95, 46, 33, 126, 42, 39, 40, 41, 59,
+ 47, 63, 58, 64, 38, 61, 43, 36, 44};
+
+ byte[] b = chkS.getBytes(encoding);
+ return java.util.Arrays.equals(b, chkB);
+ }
+
+ private class DefaultParser implements FtpDirParser {
+
+ /**
+ * Possible patterns:
+ *
+ * drwxr-xr-x 1 user01 ftp 512 Jan 29 23:32 prog
+ * drwxr-xr-x 1 user01 ftp 512 Jan 29 1997 prog
+ * drwxr-xr-x 1 1 1 512 Jan 29 23:32 prog
+ * lrwxr-xr-x 1 user01 ftp 512 Jan 29 23:32 prog -> prog2000
+ * drwxr-xr-x 1 username ftp 512 Jan 29 23:32 prog
+ * -rw-r--r-- 1 jcc staff 105009 Feb 3 15:05 test.1
+ *
+ * 01-29-97 11:32PM <DIR> prog
+ * 04/28/2006 09:12a 3,563 genBuffer.sh
+ *
+ * drwxr-xr-x folder 0 Jan 29 23:32 prog
+ *
+ * 0 DIR 01-29-97 23:32 PROG
+ */
+ private DefaultParser() {
+ }
+
+ public FtpDirEntry parseLine(String line) {
+ String fdate = null;
+ String fsize = null;
+ String time = null;
+ String filename = null;
+ String permstring = null;
+ String username = null;
+ String groupname = null;
+ boolean dir = false;
+ Calendar now = Calendar.getInstance();
+ int year = now.get(Calendar.YEAR);
+
+ Matcher m = null;
+ for (int j = 0; j < patterns.length; j++) {
+ m = patterns[j].matcher(line);
+ if (m.find()) {
+ // 0 - file, 1 - size, 2 - date, 3 - time, 4 - year,
+ // 5 - permissions, 6 - user, 7 - group
+ filename = m.group(patternGroups[j][0]);
+ fsize = m.group(patternGroups[j][1]);
+ fdate = m.group(patternGroups[j][2]);
+ if (patternGroups[j][4] > 0) {
+ fdate += (", " + m.group(patternGroups[j][4]));
+ } else if (patternGroups[j][3] > 0) {
+ fdate += (", " + String.valueOf(year));
+ }
+ if (patternGroups[j][3] > 0) {
+ time = m.group(patternGroups[j][3]);
+ }
+ if (patternGroups[j][5] > 0) {
+ permstring = m.group(patternGroups[j][5]);
+ dir = permstring.startsWith("d");
+ }
+ if (patternGroups[j][6] > 0) {
+ username = m.group(patternGroups[j][6]);
+ }
+ if (patternGroups[j][7] > 0) {
+ groupname = m.group(patternGroups[j][7]);
+ }
+ // Old DOS format
+ if ("<DIR>".equals(fsize)) {
+ dir = true;
+ fsize = null;
+ }
+ }
+ }
+
+ if (filename != null) {
+ Date d;
+ try {
+ d = df.parse(fdate);
+ } catch (Exception e) {
+ d = null;
+ }
+ if (d != null && time != null) {
+ int c = time.indexOf(':');
+ now.setTime(d);
+ now.set(Calendar.HOUR, Integer.parseInt(time.substring(0, c)));
+ now.set(Calendar.MINUTE, Integer.parseInt(time.substring(c + 1)));
+ d = now.getTime();
+ }
+ // see if it's a symbolic link, i.e. the name if followed
+ // by a -> and a path
+ Matcher m2 = linkp.matcher(filename);
+ if (m2.find()) {
+ // Keep only the name then
+ filename = m2.group(1);
+ }
+ boolean[][] perms = new boolean[3][3];
+ for (int i = 0; i < 3; i++) {
+ for (int j = 0; j < 3; j++) {
+ perms[i][j] = (permstring.charAt((i * 3) + j) != '-');
+ }
+ }
+ FtpDirEntry file = new FtpDirEntry(filename);
+ file.setUser(username).setGroup(groupname);
+ file.setSize(Long.parseLong(fsize)).setLastModified(d);
+ file.setPermissions(perms);
+ file.setType(dir ? FtpDirEntry.Type.DIR : (line.charAt(0) == 'l' ? FtpDirEntry.Type.LINK : FtpDirEntry.Type.FILE));
+ return file;
+ }
+ return null;
+ }
+ }
+
+ private class MLSxParser implements FtpDirParser {
+
+ private SimpleDateFormat df = new SimpleDateFormat("yyyyMMddhhmmss");
+
+ public FtpDirEntry parseLine(String line) {
+ String name = null;
+ int i = line.lastIndexOf(';');
+ if (i > 0) {
+ name = line.substring(i + 1).trim();
+ line = line.substring(0, i);
+ } else {
+ name = line.trim();
+ line = "";
+ }
+ FtpDirEntry file = new FtpDirEntry(name);
+ while (!line.isEmpty()) {
+ String s;
+ i = line.indexOf(';');
+ if (i > 0) {
+ s = line.substring(0, i);
+ line = line.substring(i + 1);
+ } else {
+ s = line;
+ line = "";
+ }
+ i = s.indexOf('=');
+ if (i > 0) {
+ String fact = s.substring(0, i);
+ String value = s.substring(i + 1);
+ file.addFact(fact, value);
+ }
+ }
+ String s = file.getFact("Size");
+ if (s != null) {
+ file.setSize(Long.parseLong(s));
+ }
+ s = file.getFact("Modify");
+ if (s != null) {
+ Date d = null;
+ try {
+ d = df.parse(s);
+ } catch (ParseException ex) {
+ }
+ if (d != null) {
+ file.setLastModified(d);
+ }
+ }
+ s = file.getFact("Create");
+ if (s != null) {
+ Date d = null;
+ try {
+ d = df.parse(s);
+ } catch (ParseException ex) {
+ }
+ if (d != null) {
+ file.setCreated(d);
+ }
+ }
+ s = file.getFact("Type");
+ if (s != null) {
+ if (s.equalsIgnoreCase("file")) {
+ file.setType(FtpDirEntry.Type.FILE);
+ }
+ if (s.equalsIgnoreCase("dir")) {
+ file.setType(FtpDirEntry.Type.DIR);
+ }
+ if (s.equalsIgnoreCase("cdir")) {
+ file.setType(FtpDirEntry.Type.CDIR);
+ }
+ if (s.equalsIgnoreCase("pdir")) {
+ file.setType(FtpDirEntry.Type.PDIR);
+ }
+ }
+ return file;
+ }
+ };
+ private FtpDirParser parser = new DefaultParser();
+ private FtpDirParser mlsxParser = new MLSxParser();
+ private static Pattern transPat = null;
+
+ private void getTransferSize() {
+ lastTransSize = -1;
+ /**
+ * If it's a start of data transfer response, let's try to extract
+ * the size from the response string. Usually it looks like that:
+ *
+ * 150 Opening BINARY mode data connection for foo (6701 bytes).
+ */
+ String response = getLastResponseString();
+ if (transPat == null) {
+ transPat = Pattern.compile("150 Opening .*\\((\\d+) bytes\\).");
+ }
+ Matcher m = transPat.matcher(response);
+ if (m.find()) {
+ String s = m.group(1);
+ lastTransSize = Long.parseLong(s);
+ }
+ }
+
+ /**
+ * extract the created file name from the response string:
+ * 226 Transfer complete (unique file name:toto.txt.1).
+ * Usually happens when a STOU (store unique) command had been issued.
+ */
+ private void getTransferName() {
+ lastFileName = null;
+ String response = getLastResponseString();
+ int i = response.indexOf("unique file name:");
+ int e = response.lastIndexOf(')');
+ if (i >= 0) {
+ i += 17; // Length of "unique file name:"
+ lastFileName = response.substring(i, e);
+ }
+ }
+
+ /**
+ * Pulls the response from the server and returns the code as a
+ * number. Returns -1 on failure.
+ */
+ private int readServerResponse() throws IOException {
+ StringBuilder replyBuf = new StringBuilder(32);
+ int c;
+ int continuingCode = -1;
+ int code;
+ String response;
+
+ serverResponse.setSize(0);
+ while (true) {
+ while ((c = in.read()) != -1) {
+ if (c == '\r') {
+ if ((c = in.read()) != '\n') {
+ replyBuf.append('\r');
+ }
+ }
+ replyBuf.append((char) c);
+ if (c == '\n') {
+ break;
+ }
+ }
+ response = replyBuf.toString();
+ replyBuf.setLength(0);
+ if (logger.isLoggable(PlatformLogger.Level.FINEST)) {
+ logger.finest("Server [" + serverAddr + "] --> " + response);
+ }
+
+ if (response.length() == 0) {
+ code = -1;
+ } else {
+ try {
+ code = Integer.parseInt(response.substring(0, 3));
+ } catch (NumberFormatException e) {
+ code = -1;
+ } catch (StringIndexOutOfBoundsException e) {
+ /* this line doesn't contain a response code, so
+ we just completely ignore it */
+ continue;
+ }
+ }
+ serverResponse.addElement(response);
+ if (continuingCode != -1) {
+ /* we've seen a ###- sequence */
+ if (code != continuingCode ||
+ (response.length() >= 4 && response.charAt(3) == '-')) {
+ continue;
+ } else {
+ /* seen the end of code sequence */
+ continuingCode = -1;
+ break;
+ }
+ } else if (response.length() >= 4 && response.charAt(3) == '-') {
+ continuingCode = code;
+ continue;
+ } else {
+ break;
+ }
+ }
+
+ return code;
+ }
+
+ /** Sends command <i>cmd</i> to the server. */
+ private void sendServer(String cmd) {
+ out.print(cmd);
+ if (logger.isLoggable(PlatformLogger.Level.FINEST)) {
+ logger.finest("Server [" + serverAddr + "] <-- " + cmd);
+ }
+ }
+
+ /** converts the server response into a string. */
+ private String getResponseString() {
+ return serverResponse.elementAt(0);
+ }
+
+ /** Returns all server response strings. */
+ private Vector<String> getResponseStrings() {
+ return serverResponse;
+ }
+
+ /**
+ * Read the reply from the FTP server.
+ *
+ * @return <code>true</code> if the command was successful
+ * @throws IOException if an error occurred
+ */
+ private boolean readReply() throws IOException {
+ lastReplyCode = FtpReplyCode.find(readServerResponse());
+
+ if (lastReplyCode.isPositivePreliminary()) {
+ replyPending = true;
+ return true;
+ }
+ if (lastReplyCode.isPositiveCompletion() || lastReplyCode.isPositiveIntermediate()) {
+ if (lastReplyCode == FtpReplyCode.CLOSING_DATA_CONNECTION) {
+ getTransferName();
+ }
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Sends a command to the FTP server and returns the error code
+ * (which can be a "success") sent by the server.
+ *
+ * @param cmd
+ * @return <code>true</code> if the command was successful
+ * @throws IOException
+ */
+ private boolean issueCommand(String cmd) throws IOException {
+ if (!isConnected()) {
+ throw new IllegalStateException("Not connected");
+ }
+ if (replyPending) {
+ try {
+ completePending();
+ } catch (sun.net.ftp.FtpProtocolException e) {
+ // ignore...
+ }
+ }
+ sendServer(cmd + "\r\n");
+ return readReply();
+ }
+
+ /**
+ * Send a command to the FTP server and check for success.
+ *
+ * @param cmd String containing the command
+ *
+ * @throws FtpProtocolException if an error occurred
+ */
+ private void issueCommandCheck(String cmd) throws sun.net.ftp.FtpProtocolException, IOException {
+ if (!issueCommand(cmd)) {
+ throw new sun.net.ftp.FtpProtocolException(cmd + ":" + getResponseString(), getLastReplyCode());
+ }
+ }
+ private static Pattern epsvPat = null;
+ private static Pattern pasvPat = null;
+
+ /**
+ * Opens a "PASSIVE" connection with the server and returns the connected
+ * <code>Socket</code>.
+ *
+ * @return the connected <code>Socket</code>
+ * @throws IOException if the connection was unsuccessful.
+ */
+ private Socket openPassiveDataConnection(String cmd) throws sun.net.ftp.FtpProtocolException, IOException {
+ String serverAnswer;
+ int port;
+ InetSocketAddress dest = null;
+
+ /**
+ * Here is the idea:
+ *
+ * - First we want to try the new (and IPv6 compatible) EPSV command
+ * But since we want to be nice with NAT software, we'll issue the
+ * EPSV ALL command first.
+ * EPSV is documented in RFC2428
+ * - If EPSV fails, then we fall back to the older, yet ok, PASV
+ * - If PASV fails as well, then we throw an exception and the calling
+ * method will have to try the EPRT or PORT command
+ */
+ if (issueCommand("EPSV ALL")) {
+ // We can safely use EPSV commands
+ issueCommandCheck("EPSV");
+ serverAnswer = getResponseString();
+
+ // The response string from a EPSV command will contain the port number
+ // the format will be :
+ // 229 Entering Extended PASSIVE Mode (|||58210|)
+ //
+ // So we'll use the regular expresions package to parse the output.
+
+ if (epsvPat == null) {
+ epsvPat = Pattern.compile("^229 .* \\(\\|\\|\\|(\\d+)\\|\\)");
+ }
+ Matcher m = epsvPat.matcher(serverAnswer);
+ if (!m.find()) {
+ throw new sun.net.ftp.FtpProtocolException("EPSV failed : " + serverAnswer);
+ }
+ // Yay! Let's extract the port number
+ String s = m.group(1);
+ port = Integer.parseInt(s);
+ InetAddress add = server.getInetAddress();
+ if (add != null) {
+ dest = new InetSocketAddress(add, port);
+ } else {
+ // This means we used an Unresolved address to connect in
+ // the first place. Most likely because the proxy is doing
+ // the name resolution for us, so let's keep using unresolved
+ // address.
+ dest = InetSocketAddress.createUnresolved(serverAddr.getHostName(), port);
+ }
+ } else {
+ // EPSV ALL failed, so Let's try the regular PASV cmd
+ issueCommandCheck("PASV");
+ serverAnswer = getResponseString();
+
+ // Let's parse the response String to get the IP & port to connect
+ // to. The String should be in the following format :
+ //
+ // 227 Entering PASSIVE Mode (A1,A2,A3,A4,p1,p2)
+ //
+ // Note that the two parenthesis are optional
+ //
+ // The IP address is A1.A2.A3.A4 and the port is p1 * 256 + p2
+ //
+ // The regular expression is a bit more complex this time, because
+ // the parenthesis are optionals and we have to use 3 groups.
+
+ if (pasvPat == null) {
+ pasvPat = Pattern.compile("227 .* \\(?(\\d{1,3},\\d{1,3},\\d{1,3},\\d{1,3}),(\\d{1,3}),(\\d{1,3})\\)?");
+ }
+ Matcher m = pasvPat.matcher(serverAnswer);
+ if (!m.find()) {
+ throw new sun.net.ftp.FtpProtocolException("PASV failed : " + serverAnswer);
+ }
+ // Get port number out of group 2 & 3
+ port = Integer.parseInt(m.group(3)) + (Integer.parseInt(m.group(2)) << 8);
+ // IP address is simple
+ String s = m.group(1).replace(',', '.');
+ dest = new InetSocketAddress(s, port);
+ }
+ // Got everything, let's open the socket!
+ Socket s;
+ if (proxy != null) {
+ if (proxy.type() == Proxy.Type.SOCKS) {
+ s = AccessController.doPrivileged(
+ new PrivilegedAction<Socket>() {
+
+ public Socket run() {
+ return new Socket(proxy);
+ }
+ });
+ } else {
+ s = new Socket(Proxy.NO_PROXY);
+ }
+ } else {
+ s = new Socket();
+ }
+
+ InetAddress serverAddress = AccessController.doPrivileged(
+ new PrivilegedAction<InetAddress>() {
+ @Override
+ public InetAddress run() {
+ return server.getLocalAddress();
+ }
+ });
+
+ // Bind the socket to the same address as the control channel. This
+ // is needed in case of multi-homed systems.
+ s.bind(new InetSocketAddress(serverAddress, 0));
+ if (connectTimeout >= 0) {
+ s.connect(dest, connectTimeout);
+ } else {
+ if (defaultConnectTimeout > 0) {
+ s.connect(dest, defaultConnectTimeout);
+ } else {
+ s.connect(dest);
+ }
+ }
+ if (readTimeout >= 0) {
+ s.setSoTimeout(readTimeout);
+ } else if (defaultSoTimeout > 0) {
+ s.setSoTimeout(defaultSoTimeout);
+ }
+ if (useCrypto) {
+ try {
+ s = sslFact.createSocket(s, dest.getHostName(), dest.getPort(), true);
+ } catch (Exception e) {
+ throw new sun.net.ftp.FtpProtocolException("Can't open secure data channel: " + e);
+ }
+ }
+ if (!issueCommand(cmd)) {
+ s.close();
+ if (getLastReplyCode() == FtpReplyCode.FILE_UNAVAILABLE) {
+ // Ensure backward compatibility
+ throw new FileNotFoundException(cmd);
+ }
+ throw new sun.net.ftp.FtpProtocolException(cmd + ":" + getResponseString(), getLastReplyCode());
+ }
+ return s;
+ }
+
+ /**
+ * Opens a data connection with the server according to the set mode
+ * (ACTIVE or PASSIVE) then send the command passed as an argument.
+ *
+ * @param cmd the <code>String</code> containing the command to execute
+ * @return the connected <code>Socket</code>
+ * @throws IOException if the connection or command failed
+ */
+ private Socket openDataConnection(String cmd) throws sun.net.ftp.FtpProtocolException, IOException {
+ Socket clientSocket;
+
+ if (passiveMode) {
+ try {
+ return openPassiveDataConnection(cmd);
+ } catch (sun.net.ftp.FtpProtocolException e) {
+ // If Passive mode failed, fall back on PORT
+ // Otherwise throw exception
+ String errmsg = e.getMessage();
+ if (!errmsg.startsWith("PASV") && !errmsg.startsWith("EPSV")) {
+ throw e;
+ }
+ }
+ }
+ ServerSocket portSocket;
+ InetAddress myAddress;
+ String portCmd;
+
+ if (proxy != null && proxy.type() == Proxy.Type.SOCKS) {
+ // We're behind a firewall and the passive mode fail,
+ // since we can't accept a connection through SOCKS (yet)
+ // throw an exception
+ throw new sun.net.ftp.FtpProtocolException("Passive mode failed");
+ }
+ // Bind the ServerSocket to the same address as the control channel
+ // This is needed for multi-homed systems
+ portSocket = new ServerSocket(0, 1, server.getLocalAddress());
+ try {
+ myAddress = portSocket.getInetAddress();
+ if (myAddress.isAnyLocalAddress()) {
+ myAddress = server.getLocalAddress();
+ }
+ // Let's try the new, IPv6 compatible EPRT command
+ // See RFC2428 for specifics
+ // Some FTP servers (like the one on Solaris) are bugged, they
+ // will accept the EPRT command but then, the subsequent command
+ // (e.g. RETR) will fail, so we have to check BOTH results (the
+ // EPRT cmd then the actual command) to decide whether we should
+ // fall back on the older PORT command.
+ portCmd = "EPRT |" + ((myAddress instanceof Inet6Address) ? "2" : "1") + "|" +
+ myAddress.getHostAddress() + "|" + portSocket.getLocalPort() + "|";
+ if (!issueCommand(portCmd) || !issueCommand(cmd)) {
+ // The EPRT command failed, let's fall back to good old PORT
+ portCmd = "PORT ";
+ byte[] addr = myAddress.getAddress();
+
+ /* append host addr */
+ for (int i = 0; i < addr.length; i++) {
+ portCmd = portCmd + (addr[i] & 0xFF) + ",";
+ }
+
+ /* append port number */
+ portCmd = portCmd + ((portSocket.getLocalPort() >>> 8) & 0xff) + "," + (portSocket.getLocalPort() & 0xff);
+ issueCommandCheck(portCmd);
+ issueCommandCheck(cmd);
+ }
+ // Either the EPRT or the PORT command was successful
+ // Let's create the client socket
+ if (connectTimeout >= 0) {
+ portSocket.setSoTimeout(connectTimeout);
+ } else {
+ if (defaultConnectTimeout > 0) {
+ portSocket.setSoTimeout(defaultConnectTimeout);
+ }
+ }
+ clientSocket = portSocket.accept();
+ if (readTimeout >= 0) {
+ clientSocket.setSoTimeout(readTimeout);
+ } else {
+ if (defaultSoTimeout > 0) {
+ clientSocket.setSoTimeout(defaultSoTimeout);
+ }
+ }
+ } finally {
+ portSocket.close();
+ }
+ if (useCrypto) {
+ try {
+ clientSocket = sslFact.createSocket(clientSocket, serverAddr.getHostName(), serverAddr.getPort(), true);
+ } catch (Exception ex) {
+ throw new IOException(ex.getLocalizedMessage());
+ }
+ }
+ return clientSocket;
+ }
+
+ private InputStream createInputStream(InputStream in) {
+ if (type == TransferType.ASCII) {
+ return new sun.net.TelnetInputStream(in, false);
+ }
+ return in;
+ }
+
+ private OutputStream createOutputStream(OutputStream out) {
+ if (type == TransferType.ASCII) {
+ return new sun.net.TelnetOutputStream(out, false);
+ }
+ return out;
+ }
+
+ /**
+ * Creates an instance of FtpClient. The client is not connected to any
+ * server yet.
+ *
+ */
+ protected FtpClient() {
+ }
+
+ /**
+ * Creates an instance of FtpClient. The client is not connected to any
+ * server yet.
+ *
+ */
+ public static sun.net.ftp.FtpClient create() {
+ return new FtpClient();
+ }
+
+ /**
+ * Set the transfer mode to <I>passive</I>. In that mode, data connections
+ * are established by having the client connect to the server.
+ * This is the recommended default mode as it will work best through
+ * firewalls and NATs.
+ *
+ * @return This FtpClient
+ * @see #setActiveMode()
+ */
+ public sun.net.ftp.FtpClient enablePassiveMode(boolean passive) {
+
+ // Only passive mode used in JDK. See Bug 8010784.
+ // passiveMode = passive;
+ return this;
+ }
+
+ /**
+ * Gets the current transfer mode.
+ *
+ * @return the current <code>FtpTransferMode</code>
+ */
+ public boolean isPassiveModeEnabled() {
+ return passiveMode;
+ }
+
+ /**
+ * Sets the timeout value to use when connecting to the server,
+ *
+ * @param timeout the timeout value, in milliseconds, to use for the connect
+ * operation. A value of zero or less, means use the default timeout.
+ *
+ * @return This FtpClient
+ */
+ public sun.net.ftp.FtpClient setConnectTimeout(int timeout) {
+ connectTimeout = timeout;
+ return this;
+ }
+
+ /**
+ * Returns the current connection timeout value.
+ *
+ * @return the value, in milliseconds, of the current connect timeout.
+ * @see #setConnectTimeout(int)
+ */
+ public int getConnectTimeout() {
+ return connectTimeout;
+ }
+
+ /**
+ * Sets the timeout value to use when reading from the server,
+ *
+ * @param timeout the timeout value, in milliseconds, to use for the read
+ * operation. A value of zero or less, means use the default timeout.
+ * @return This FtpClient
+ */
+ public sun.net.ftp.FtpClient setReadTimeout(int timeout) {
+ readTimeout = timeout;
+ return this;
+ }
+
+ /**
+ * Returns the current read timeout value.
+ *
+ * @return the value, in milliseconds, of the current read timeout.
+ * @see #setReadTimeout(int)
+ */
+ public int getReadTimeout() {
+ return readTimeout;
+ }
+
+ public sun.net.ftp.FtpClient setProxy(Proxy p) {
+ proxy = p;
+ return this;
+ }
+
+ /**
+ * Get the proxy of this FtpClient
+ *
+ * @return the <code>Proxy</code>, this client is using, or <code>null</code>
+ * if none is used.
+ * @see #setProxy(Proxy)
+ */
+ public Proxy getProxy() {
+ return proxy;
+ }
+
+ /**
+ * Connects to the specified destination.
+ *
+ * @param dest the <code>InetSocketAddress</code> to connect to.
+ * @throws IOException if the connection fails.
+ */
+ private void tryConnect(InetSocketAddress dest, int timeout) throws IOException {
+ if (isConnected()) {
+ disconnect();
+ }
+ server = doConnect(dest, timeout);
+ try {
+ out = new PrintStream(new BufferedOutputStream(server.getOutputStream()),
+ true, encoding);
+ } catch (UnsupportedEncodingException e) {
+ throw new InternalError(encoding + "encoding not found", e);
+ }
+ in = new BufferedInputStream(server.getInputStream());
+ }
+
+ private Socket doConnect(InetSocketAddress dest, int timeout) throws IOException {
+ Socket s;
+ if (proxy != null) {
+ if (proxy.type() == Proxy.Type.SOCKS) {
+ s = AccessController.doPrivileged(
+ new PrivilegedAction<Socket>() {
+
+ public Socket run() {
+ return new Socket(proxy);
+ }
+ });
+ } else {
+ s = new Socket(Proxy.NO_PROXY);
+ }
+ } else {
+ s = new Socket();
+ }
+ // Instance specific timeouts do have priority, that means
+ // connectTimeout & readTimeout (-1 means not set)
+ // Then global default timeouts
+ // Then no timeout.
+ if (timeout >= 0) {
+ s.connect(dest, timeout);
+ } else {
+ if (connectTimeout >= 0) {
+ s.connect(dest, connectTimeout);
+ } else {
+ if (defaultConnectTimeout > 0) {
+ s.connect(dest, defaultConnectTimeout);
+ } else {
+ s.connect(dest);
+ }
+ }
+ }
+ if (readTimeout >= 0) {
+ s.setSoTimeout(readTimeout);
+ } else if (defaultSoTimeout > 0) {
+ s.setSoTimeout(defaultSoTimeout);
+ }
+ return s;
+ }
+
+ private void disconnect() throws IOException {
+ if (isConnected()) {
+ server.close();
+ }
+ server = null;
+ in = null;
+ out = null;
+ lastTransSize = -1;
+ lastFileName = null;
+ restartOffset = 0;
+ welcomeMsg = null;
+ lastReplyCode = null;
+ serverResponse.setSize(0);
+ }
+
+ /**
+ * Tests whether this client is connected or not to a server.
+ *
+ * @return <code>true</code> if the client is connected.
+ */
+ public boolean isConnected() {
+ return server != null;
+ }
+
+ public SocketAddress getServerAddress() {
+ return server == null ? null : server.getRemoteSocketAddress();
+ }
+
+ public sun.net.ftp.FtpClient connect(SocketAddress dest) throws sun.net.ftp.FtpProtocolException, IOException {
+ return connect(dest, -1);
+ }
+
+ /**
+ * Connects the FtpClient to the specified destination.
+ *
+ * @param dest the address of the destination server
+ * @throws IOException if connection failed.
+ */
+ public sun.net.ftp.FtpClient connect(SocketAddress dest, int timeout) throws sun.net.ftp.FtpProtocolException, IOException {
+ if (!(dest instanceof InetSocketAddress)) {
+ throw new IllegalArgumentException("Wrong address type");
+ }
+ serverAddr = (InetSocketAddress) dest;
+ tryConnect(serverAddr, timeout);
+ if (!readReply()) {
+ throw new sun.net.ftp.FtpProtocolException("Welcome message: " +
+ getResponseString(), lastReplyCode);
+ }
+ welcomeMsg = getResponseString().substring(4);
+ return this;
+ }
+
+ private void tryLogin(String user, char[] password) throws sun.net.ftp.FtpProtocolException, IOException {
+ issueCommandCheck("USER " + user);
+
+ /*
+ * Checks for "331 User name okay, need password." answer
+ */
+ if (lastReplyCode == FtpReplyCode.NEED_PASSWORD) {
+ if ((password != null) && (password.length > 0)) {
+ issueCommandCheck("PASS " + String.valueOf(password));
+ }
+ }
+ }
+
+ /**
+ * Attempts to log on the server with the specified user name and password.
+ *
+ * @param user The user name
+ * @param password The password for that user
+ * @return <code>true</code> if the login was successful.
+ * @throws IOException if an error occurred during the transmission
+ */
+ public sun.net.ftp.FtpClient login(String user, char[] password) throws sun.net.ftp.FtpProtocolException, IOException {
+ if (!isConnected()) {
+ throw new sun.net.ftp.FtpProtocolException("Not connected yet", FtpReplyCode.BAD_SEQUENCE);
+ }
+ if (user == null || user.length() == 0) {
+ throw new IllegalArgumentException("User name can't be null or empty");
+ }
+ tryLogin(user, password);
+
+ // keep the welcome message around so we can
+ // put it in the resulting HTML page.
+ String l;
+ StringBuilder sb = new StringBuilder();
+ for (int i = 0; i < serverResponse.size(); i++) {
+ l = serverResponse.elementAt(i);
+ if (l != null) {
+ if (l.length() >= 4 && l.startsWith("230")) {
+ // get rid of the "230-" prefix
+ l = l.substring(4);
+ }
+ sb.append(l);
+ }
+ }
+ welcomeMsg = sb.toString();
+ loggedIn = true;
+ return this;
+ }
+
+ /**
+ * Attempts to log on the server with the specified user name, password and
+ * account name.
+ *
+ * @param user The user name
+ * @param password The password for that user.
+ * @param account The account name for that user.
+ * @return <code>true</code> if the login was successful.
+ * @throws IOException if an error occurs during the transmission.
+ */
+ public sun.net.ftp.FtpClient login(String user, char[] password, String account) throws sun.net.ftp.FtpProtocolException, IOException {
+
+ if (!isConnected()) {
+ throw new sun.net.ftp.FtpProtocolException("Not connected yet", FtpReplyCode.BAD_SEQUENCE);
+ }
+ if (user == null || user.length() == 0) {
+ throw new IllegalArgumentException("User name can't be null or empty");
+ }
+ tryLogin(user, password);
+
+ /*
+ * Checks for "332 Need account for login." answer
+ */
+ if (lastReplyCode == FtpReplyCode.NEED_ACCOUNT) {
+ issueCommandCheck("ACCT " + account);
+ }
+
+ // keep the welcome message around so we can
+ // put it in the resulting HTML page.
+ StringBuilder sb = new StringBuilder();
+ if (serverResponse != null) {
+ for (String l : serverResponse) {
+ if (l != null) {
+ if (l.length() >= 4 && l.startsWith("230")) {
+ // get rid of the "230-" prefix
+ l = l.substring(4);
+ }
+ sb.append(l);
+ }
+ }
+ }
+ welcomeMsg = sb.toString();
+ loggedIn = true;
+ return this;
+ }
+
+ /**
+ * Logs out the current user. This is in effect terminates the current
+ * session and the connection to the server will be closed.
+ *
+ */
+ public void close() throws IOException {
+ if (isConnected()) {
+ issueCommand("QUIT");
+ loggedIn = false;
+ }
+ disconnect();
+ }
+
+ /**
+ * Checks whether the client is logged in to the server or not.
+ *
+ * @return <code>true</code> if the client has already completed a login.
+ */
+ public boolean isLoggedIn() {
+ return loggedIn;
+ }
+
+ /**
+ * Changes to a specific directory on a remote FTP server
+ *
+ * @param remoteDirectory path of the directory to CD to.
+ * @return <code>true</code> if the operation was successful.
+ * @exception <code>FtpProtocolException</code>
+ */
+ public sun.net.ftp.FtpClient changeDirectory(String remoteDirectory) throws sun.net.ftp.FtpProtocolException, IOException {
+ if (remoteDirectory == null || "".equals(remoteDirectory)) {
+ throw new IllegalArgumentException("directory can't be null or empty");
+ }
+
+ issueCommandCheck("CWD " + remoteDirectory);
+ return this;
+ }
+
+ /**
+ * Changes to the parent directory, sending the CDUP command to the server.
+ *
+ * @return <code>true</code> if the command was successful.
+ * @throws IOException
+ */
+ public sun.net.ftp.FtpClient changeToParentDirectory() throws sun.net.ftp.FtpProtocolException, IOException {
+ issueCommandCheck("CDUP");
+ return this;
+ }
+
+ /**
+ * Returns the server current working directory, or <code>null</code> if
+ * the PWD command failed.
+ *
+ * @return a <code>String</code> containing the current working directory,
+ * or <code>null</code>
+ * @throws IOException
+ */
+ public String getWorkingDirectory() throws sun.net.ftp.FtpProtocolException, IOException {
+ issueCommandCheck("PWD");
+ /*
+ * answer will be of the following format :
+ *
+ * 257 "/" is current directory.
+ */
+ String answ = getResponseString();
+ if (!answ.startsWith("257")) {
+ return null;
+ }
+ return answ.substring(5, answ.lastIndexOf('"'));
+ }
+
+ /**
+ * Sets the restart offset to the specified value. That value will be
+ * sent through a <code>REST</code> command to server before a file
+ * transfer and has the effect of resuming a file transfer from the
+ * specified point. After a transfer the restart offset is set back to
+ * zero.
+ *
+ * @param offset the offset in the remote file at which to start the next
+ * transfer. This must be a value greater than or equal to zero.
+ * @throws IllegalArgumentException if the offset is negative.
+ */
+ public sun.net.ftp.FtpClient setRestartOffset(long offset) {
+ if (offset < 0) {
+ throw new IllegalArgumentException("offset can't be negative");
+ }
+ restartOffset = offset;
+ return this;
+ }
+
+ /**
+ * Retrieves a file from the ftp server and writes it to the specified
+ * <code>OutputStream</code>.
+ * If the restart offset was set, then a <code>REST</code> command will be
+ * sent before the RETR in order to restart the tranfer from the specified
+ * offset.
+ * The <code>OutputStream</code> is not closed by this method at the end
+ * of the transfer.
+ *
+ * @param name a <code>String<code> containing the name of the file to
+ * retreive from the server.
+ * @param local the <code>OutputStream</code> the file should be written to.
+ * @throws IOException if the transfer fails.
+ */
+ public sun.net.ftp.FtpClient getFile(String name, OutputStream local) throws sun.net.ftp.FtpProtocolException, IOException {
+ int mtu = 1500;
+ if (restartOffset > 0) {
+ Socket s;
+ try {
+ s = openDataConnection("REST " + restartOffset);
+ } finally {
+ restartOffset = 0;
+ }
+ issueCommandCheck("RETR " + name);
+ getTransferSize();
+ InputStream remote = createInputStream(s.getInputStream());
+ byte[] buf = new byte[mtu * 10];
+ int l;
+ while ((l = remote.read(buf)) >= 0) {
+ if (l > 0) {
+ local.write(buf, 0, l);
+ }
+ }
+ remote.close();
+ } else {
+ Socket s = openDataConnection("RETR " + name);
+ getTransferSize();
+ InputStream remote = createInputStream(s.getInputStream());
+ byte[] buf = new byte[mtu * 10];
+ int l;
+ while ((l = remote.read(buf)) >= 0) {
+ if (l > 0) {
+ local.write(buf, 0, l);
+ }
+ }
+ remote.close();
+ }
+ return completePending();
+ }
+
+ /**
+ * Retrieves a file from the ftp server, using the RETR command, and
+ * returns the InputStream from* the established data connection.
+ * {@link #completePending()} <b>has</b> to be called once the application
+ * is done reading from the returned stream.
+ *
+ * @param name the name of the remote file
+ * @return the {@link java.io.InputStream} from the data connection, or
+ * <code>null</code> if the command was unsuccessful.
+ * @throws IOException if an error occurred during the transmission.
+ */
+ public InputStream getFileStream(String name) throws sun.net.ftp.FtpProtocolException, IOException {
+ Socket s;
+ if (restartOffset > 0) {
+ try {
+ s = openDataConnection("REST " + restartOffset);
+ } finally {
+ restartOffset = 0;
+ }
+ if (s == null) {
+ return null;
+ }
+ issueCommandCheck("RETR " + name);
+ getTransferSize();
+ return createInputStream(s.getInputStream());
+ }
+
+ s = openDataConnection("RETR " + name);
+ if (s == null) {
+ return null;
+ }
+ getTransferSize();
+ return createInputStream(s.getInputStream());
+ }
+
+ /**
+ * Transfers a file from the client to the server (aka a <I>put</I>)
+ * by sending the STOR or STOU command, depending on the
+ * <code>unique</code> argument, and returns the <code>OutputStream</code>
+ * from the established data connection.
+ * {@link #completePending()} <b>has</b> to be called once the application
+ * is finished writing to the stream.
+ *
+ * A new file is created at the server site if the file specified does
+ * not already exist.
+ *
+ * If <code>unique</code> is set to <code>true</code>, the resultant file
+ * is to be created under a name unique to that directory, meaning
+ * it will not overwrite an existing file, instead the server will
+ * generate a new, unique, file name.
+ * The name of the remote file can be retrieved, after completion of the
+ * transfer, by calling {@link #getLastFileName()}.
+ *
+ * @param name the name of the remote file to write.
+ * @param unique <code>true</code> if the remote files should be unique,
+ * in which case the STOU command will be used.
+ * @return the {@link java.io.OutputStream} from the data connection or
+ * <code>null</code> if the command was unsuccessful.
+ * @throws IOException if an error occurred during the transmission.
+ */
+ public OutputStream putFileStream(String name, boolean unique)
+ throws sun.net.ftp.FtpProtocolException, IOException
+ {
+ String cmd = unique ? "STOU " : "STOR ";
+ Socket s = openDataConnection(cmd + name);
+ if (s == null) {
+ return null;
+ }
+ boolean bm = (type == TransferType.BINARY);
+ return new sun.net.TelnetOutputStream(s.getOutputStream(), bm);
+ }
+
+ /**
+ * Transfers a file from the client to the server (aka a <I>put</I>)
+ * by sending the STOR command. The content of the <code>InputStream</code>
+ * passed in argument is written into the remote file, overwriting any
+ * existing data.
+ *
+ * A new file is created at the server site if the file specified does
+ * not already exist.
+ *
+ * @param name the name of the remote file to write.
+ * @param local the <code>InputStream</code> that points to the data to
+ * transfer.
+ * @param unique <code>true</code> if the remote file should be unique
+ * (i.e. not already existing), <code>false</code> otherwise.
+ * @return <code>true</code> if the transfer was successful.
+ * @throws IOException if an error occurred during the transmission.
+ * @see #getLastFileName()
+ */
+ public sun.net.ftp.FtpClient putFile(String name, InputStream local, boolean unique) throws sun.net.ftp.FtpProtocolException, IOException {
+ String cmd = unique ? "STOU " : "STOR ";
+ int mtu = 1500;
+ if (type == TransferType.BINARY) {
+ Socket s = openDataConnection(cmd + name);
+ OutputStream remote = createOutputStream(s.getOutputStream());
+ byte[] buf = new byte[mtu * 10];
+ int l;
+ while ((l = local.read(buf)) >= 0) {
+ if (l > 0) {
+ remote.write(buf, 0, l);
+ }
+ }
+ remote.close();
+ }
+ return completePending();
+ }
+
+ /**
+ * Sends the APPE command to the server in order to transfer a data stream
+ * passed in argument and append it to the content of the specified remote
+ * file.
+ *
+ * @param name A <code>String</code> containing the name of the remote file
+ * to append to.
+ * @param local The <code>InputStream</code> providing access to the data
+ * to be appended.
+ * @return <code>true</code> if the transfer was successful.
+ * @throws IOException if an error occurred during the transmission.
+ */
+ public sun.net.ftp.FtpClient appendFile(String name, InputStream local) throws sun.net.ftp.FtpProtocolException, IOException {
+ int mtu = 1500;
+ Socket s = openDataConnection("APPE " + name);
+ OutputStream remote = createOutputStream(s.getOutputStream());
+ byte[] buf = new byte[mtu * 10];
+ int l;
+ while ((l = local.read(buf)) >= 0) {
+ if (l > 0) {
+ remote.write(buf, 0, l);
+ }
+ }
+ remote.close();
+ return completePending();
+ }
+
+ /**
+ * Renames a file on the server.
+ *
+ * @param from the name of the file being renamed
+ * @param to the new name for the file
+ * @throws IOException if the command fails
+ */
+ public sun.net.ftp.FtpClient rename(String from, String to) throws sun.net.ftp.FtpProtocolException, IOException {
+ issueCommandCheck("RNFR " + from);
+ issueCommandCheck("RNTO " + to);
+ return this;
+ }
+
+ /**
+ * Deletes a file on the server.
+ *
+ * @param name a <code>String</code> containing the name of the file
+ * to delete.
+ * @return <code>true</code> if the command was successful
+ * @throws IOException if an error occurred during the exchange
+ */
+ public sun.net.ftp.FtpClient deleteFile(String name) throws sun.net.ftp.FtpProtocolException, IOException {
+ issueCommandCheck("DELE " + name);
+ return this;
+ }
+
+ /**
+ * Creates a new directory on the server.
+ *
+ * @param name a <code>String</code> containing the name of the directory
+ * to create.
+ * @return <code>true</code> if the operation was successful.
+ * @throws IOException if an error occurred during the exchange
+ */
+ public sun.net.ftp.FtpClient makeDirectory(String name) throws sun.net.ftp.FtpProtocolException, IOException {
+ issueCommandCheck("MKD " + name);
+ return this;
+ }
+
+ /**
+ * Removes a directory on the server.
+ *
+ * @param name a <code>String</code> containing the name of the directory
+ * to remove.
+ *
+ * @return <code>true</code> if the operation was successful.
+ * @throws IOException if an error occurred during the exchange.
+ */
+ public sun.net.ftp.FtpClient removeDirectory(String name) throws sun.net.ftp.FtpProtocolException, IOException {
+ issueCommandCheck("RMD " + name);
+ return this;
+ }
+
+ /**
+ * Sends a No-operation command. It's useful for testing the connection
+ * status or as a <I>keep alive</I> mechanism.
+ *
+ * @throws FtpProtocolException if the command fails
+ */
+ public sun.net.ftp.FtpClient noop() throws sun.net.ftp.FtpProtocolException, IOException {
+ issueCommandCheck("NOOP");
+ return this;
+ }
+
+ /**
+ * Sends the STAT command to the server.
+ * This can be used while a data connection is open to get a status
+ * on the current transfer, in that case the parameter should be
+ * <code>null</code>.
+ * If used between file transfers, it may have a pathname as argument
+ * in which case it will work as the LIST command except no data
+ * connection will be created.
+ *
+ * @param name an optional <code>String</code> containing the pathname
+ * the STAT command should apply to.
+ * @return the response from the server or <code>null</code> if the
+ * command failed.
+ * @throws IOException if an error occurred during the transmission.
+ */
+ public String getStatus(String name) throws sun.net.ftp.FtpProtocolException, IOException {
+ issueCommandCheck((name == null ? "STAT" : "STAT " + name));
+ /*
+ * A typical response will be:
+ * 213-status of t32.gif:
+ * -rw-r--r-- 1 jcc staff 247445 Feb 17 1998 t32.gif
+ * 213 End of Status
+ *
+ * or
+ *
+ * 211-jsn FTP server status:
+ * Version wu-2.6.2+Sun
+ * Connected to localhost (::1)
+ * Logged in as jccollet
+ * TYPE: ASCII, FORM: Nonprint; STRUcture: File; transfer MODE: Stream
+ * No data connection
+ * 0 data bytes received in 0 files
+ * 0 data bytes transmitted in 0 files
+ * 0 data bytes total in 0 files
+ * 53 traffic bytes received in 0 transfers
+ * 485 traffic bytes transmitted in 0 transfers
+ * 587 traffic bytes total in 0 transfers
+ * 211 End of status
+ *
+ * So we need to remove the 1st and last line
+ */
+ Vector<String> resp = getResponseStrings();
+ StringBuilder sb = new StringBuilder();
+ for (int i = 1; i < resp.size() - 1; i++) {
+ sb.append(resp.get(i));
+ }
+ return sb.toString();
+ }
+
+ /**
+ * Sends the FEAT command to the server and returns the list of supported
+ * features in the form of strings.
+ *
+ * The features are the supported commands, like AUTH TLS, PROT or PASV.
+ * See the RFCs for a complete list.
+ *
+ * Note that not all FTP servers support that command, in which case
+ * the method will return <code>null</code>
+ *
+ * @return a <code>List</code> of <code>Strings</code> describing the
+ * supported additional features, or <code>null</code>
+ * if the command is not supported.
+ * @throws IOException if an error occurs during the transmission.
+ */
+ public List<String> getFeatures() throws sun.net.ftp.FtpProtocolException, IOException {
+ /*
+ * The FEAT command, when implemented will return something like:
+ *
+ * 211-Features:
+ * AUTH TLS
+ * PBSZ
+ * PROT
+ * EPSV
+ * EPRT
+ * PASV
+ * REST STREAM
+ * 211 END
+ */
+ ArrayList<String> features = new ArrayList<String>();
+ issueCommandCheck("FEAT");
+ Vector<String> resp = getResponseStrings();
+ // Note that we start at index 1 to skip the 1st line (211-...)
+ // and we stop before the last line.
+ for (int i = 1; i < resp.size() - 1; i++) {
+ String s = resp.get(i);
+ // Get rid of leading space and trailing newline
+ features.add(s.substring(1, s.length() - 1));
+ }
+ return features;
+ }
+
+ /**
+ * sends the ABOR command to the server.
+ * It tells the server to stop the previous command or transfer.
+ *
+ * @return <code>true</code> if the command was successful.
+ * @throws IOException if an error occurred during the transmission.
+ */
+ public sun.net.ftp.FtpClient abort() throws sun.net.ftp.FtpProtocolException, IOException {
+ issueCommandCheck("ABOR");
+ // TODO: Must check the ReplyCode:
+ /*
+ * From the RFC:
+ * There are two cases for the server upon receipt of this
+ * command: (1) the FTP service command was already completed,
+ * or (2) the FTP service command is still in progress.
+ * In the first case, the server closes the data connection
+ * (if it is open) and responds with a 226 reply, indicating
+ * that the abort command was successfully processed.
+ * In the second case, the server aborts the FTP service in
+ * progress and closes the data connection, returning a 426
+ * reply to indicate that the service request terminated
+ * abnormally. The server then sends a 226 reply,
+ * indicating that the abort command was successfully
+ * processed.
+ */
+
+
+ return this;
+ }
+
+ /**
+ * Some methods do not wait until completion before returning, so this
+ * method can be called to wait until completion. This is typically the case
+ * with commands that trigger a transfer like {@link #getFileStream(String)}.
+ * So this method should be called before accessing information related to
+ * such a command.
+ * <p>This method will actually block reading on the command channel for a
+ * notification from the server that the command is finished. Such a
+ * notification often carries extra information concerning the completion
+ * of the pending action (e.g. number of bytes transfered).</p>
+ * <p>Note that this will return true immediately if no command or action
+ * is pending</p>
+ * <p>It should be also noted that most methods issuing commands to the ftp
+ * server will call this method if a previous command is pending.
+ * <p>Example of use:
+ * <pre>
+ * InputStream in = cl.getFileStream("file");
+ * ...
+ * cl.completePending();
+ * long size = cl.getLastTransferSize();
+ * </pre>
+ * On the other hand, it's not necessary in a case like:
+ * <pre>
+ * InputStream in = cl.getFileStream("file");
+ * // read content
+ * ...
+ * cl.logout();
+ * </pre>
+ * <p>Since {@link #logout()} will call completePending() if necessary.</p>
+ * @return <code>true</code> if the completion was successful or if no
+ * action was pending.
+ * @throws IOException
+ */
+ public sun.net.ftp.FtpClient completePending() throws sun.net.ftp.FtpProtocolException, IOException {
+ while (replyPending) {
+ replyPending = false;
+ if (!readReply()) {
+ throw new sun.net.ftp.FtpProtocolException(getLastResponseString(), lastReplyCode);
+ }
+ }
+ return this;
+ }
+
+ /**
+ * Reinitializes the USER parameters on the FTP server
+ *
+ * @throws FtpProtocolException if the command fails
+ */
+ public sun.net.ftp.FtpClient reInit() throws sun.net.ftp.FtpProtocolException, IOException {
+ issueCommandCheck("REIN");
+ loggedIn = false;
+ if (useCrypto) {
+ if (server instanceof SSLSocket) {
+ javax.net.ssl.SSLSession session = ((SSLSocket) server).getSession();
+ session.invalidate();
+ // Restore previous socket and streams
+ server = oldSocket;
+ oldSocket = null;
+ try {
+ out = new PrintStream(new BufferedOutputStream(server.getOutputStream()),
+ true, encoding);
+ } catch (UnsupportedEncodingException e) {
+ throw new InternalError(encoding + "encoding not found", e);
+ }
+ in = new BufferedInputStream(server.getInputStream());
+ }
+ }
+ useCrypto = false;
+ return this;
+ }
+
+ /**
+ * Changes the transfer type (binary, ascii, ebcdic) and issue the
+ * proper command (e.g. TYPE A) to the server.
+ *
+ * @param type the <code>FtpTransferType</code> to use.
+ * @return This FtpClient
+ * @throws IOException if an error occurs during transmission.
+ */
+ public sun.net.ftp.FtpClient setType(TransferType type) throws sun.net.ftp.FtpProtocolException, IOException {
+ String cmd = "NOOP";
+
+ this.type = type;
+ if (type == TransferType.ASCII) {
+ cmd = "TYPE A";
+ }
+ if (type == TransferType.BINARY) {
+ cmd = "TYPE I";
+ }
+ if (type == TransferType.EBCDIC) {
+ cmd = "TYPE E";
+ }
+ issueCommandCheck(cmd);
+ return this;
+ }
+
+ /**
+ * Issues a LIST command to the server to get the current directory
+ * listing, and returns the InputStream from the data connection.
+ * {@link #completePending()} <b>has</b> to be called once the application
+ * is finished writing to the stream.
+ *
+ * @param path the pathname of the directory to list, or <code>null</code>
+ * for the current working directory.
+ * @return the <code>InputStream</code> from the resulting data connection
+ * @throws IOException if an error occurs during the transmission.
+ * @see #changeDirectory(String)
+ * @see #listFiles(String)
+ */
+ public InputStream list(String path) throws sun.net.ftp.FtpProtocolException, IOException {
+ Socket s;
+ s = openDataConnection(path == null ? "LIST" : "LIST " + path);
+ if (s != null) {
+ return createInputStream(s.getInputStream());
+ }
+ return null;
+ }
+
+ /**
+ * Issues a NLST path command to server to get the specified directory
+ * content. It differs from {@link #list(String)} method by the fact that
+ * it will only list the file names which would make the parsing of the
+ * somewhat easier.
+ *
+ * {@link #completePending()} <b>has</b> to be called once the application
+ * is finished writing to the stream.
+ *
+ * @param path a <code>String</code> containing the pathname of the
+ * directory to list or <code>null</code> for the current working
+ * directory.
+ * @return the <code>InputStream</code> from the resulting data connection
+ * @throws IOException if an error occurs during the transmission.
+ */
+ public InputStream nameList(String path) throws sun.net.ftp.FtpProtocolException, IOException {
+ Socket s;
+ s = openDataConnection("NLST " + path);
+ if (s != null) {
+ return createInputStream(s.getInputStream());
+ }
+ return null;
+ }
+
+ /**
+ * Issues the SIZE [path] command to the server to get the size of a
+ * specific file on the server.
+ * Note that this command may not be supported by the server. In which
+ * case -1 will be returned.
+ *
+ * @param path a <code>String</code> containing the pathname of the
+ * file.
+ * @return a <code>long</code> containing the size of the file or -1 if
+ * the server returned an error, which can be checked with
+ * {@link #getLastReplyCode()}.
+ * @throws IOException if an error occurs during the transmission.
+ */
+ public long getSize(String path) throws sun.net.ftp.FtpProtocolException, IOException {
+ if (path == null || path.length() == 0) {
+ throw new IllegalArgumentException("path can't be null or empty");
+ }
+ issueCommandCheck("SIZE " + path);
+ if (lastReplyCode == FtpReplyCode.FILE_STATUS) {
+ String s = getResponseString();
+ s = s.substring(4, s.length() - 1);
+ return Long.parseLong(s);
+ }
+ return -1;
+ }
+ private static String[] MDTMformats = {
+ "yyyyMMddHHmmss.SSS",
+ "yyyyMMddHHmmss"
+ };
+ private static SimpleDateFormat[] dateFormats = new SimpleDateFormat[MDTMformats.length];
+
+ static {
+ for (int i = 0; i < MDTMformats.length; i++) {
+ dateFormats[i] = new SimpleDateFormat(MDTMformats[i]);
+ dateFormats[i].setTimeZone(TimeZone.getTimeZone("GMT"));
+ }
+ }
+
+ /**
+ * Issues the MDTM [path] command to the server to get the modification
+ * time of a specific file on the server.
+ * Note that this command may not be supported by the server, in which
+ * case <code>null</code> will be returned.
+ *
+ * @param path a <code>String</code> containing the pathname of the file.
+ * @return a <code>Date</code> representing the last modification time
+ * or <code>null</code> if the server returned an error, which
+ * can be checked with {@link #getLastReplyCode()}.
+ * @throws IOException if an error occurs during the transmission.
+ */
+ public Date getLastModified(String path) throws sun.net.ftp.FtpProtocolException, IOException {
+ issueCommandCheck("MDTM " + path);
+ if (lastReplyCode == FtpReplyCode.FILE_STATUS) {
+ String s = getResponseString().substring(4);
+ Date d = null;
+ for (SimpleDateFormat dateFormat : dateFormats) {
+ try {
+ d = dateFormat.parse(s);
+ } catch (ParseException ex) {
+ }
+ if (d != null) {
+ return d;
+ }
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Sets the parser used to handle the directory output to the specified
+ * one. By default the parser is set to one that can handle most FTP
+ * servers output (Unix base mostly). However it may be necessary for
+ * and application to provide its own parser due to some uncommon
+ * output format.
+ *
+ * @param p The <code>FtpDirParser</code> to use.
+ * @see #listFiles(String)
+ */
+ public sun.net.ftp.FtpClient setDirParser(FtpDirParser p) {
+ parser = p;
+ return this;
+ }
+
+ private class FtpFileIterator implements Iterator<FtpDirEntry>, Closeable {
+
+ private BufferedReader in = null;
+ private FtpDirEntry nextFile = null;
+ private FtpDirParser fparser = null;
+ private boolean eof = false;
+
+ public FtpFileIterator(FtpDirParser p, BufferedReader in) {
+ this.in = in;
+ this.fparser = p;
+ readNext();
+ }
+
+ private void readNext() {
+ nextFile = null;
+ if (eof) {
+ return;
+ }
+ String line = null;
+ try {
+ do {
+ line = in.readLine();
+ if (line != null) {
+ nextFile = fparser.parseLine(line);
+ if (nextFile != null) {
+ return;
+ }
+ }
+ } while (line != null);
+ in.close();
+ } catch (IOException iOException) {
+ }
+ eof = true;
+ }
+
+ public boolean hasNext() {
+ return nextFile != null;
+ }
+
+ public FtpDirEntry next() {
+ FtpDirEntry ret = nextFile;
+ readNext();
+ return ret;
+ }
+
+ public void remove() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void close() throws IOException {
+ if (in != null && !eof) {
+ in.close();
+ }
+ eof = true;
+ nextFile = null;
+ }
+ }
+
+ /**
+ * Issues a MLSD command to the server to get the specified directory
+ * listing and applies the current parser to create an Iterator of
+ * {@link java.net.ftp.FtpDirEntry}. Note that the Iterator returned is also a
+ * {@link java.io.Closeable}.
+ * If the server doesn't support the MLSD command, the LIST command is used
+ * instead.
+ *
+ * {@link #completePending()} <b>has</b> to be called once the application
+ * is finished iterating through the files.
+ *
+ * @param path the pathname of the directory to list or <code>null</code>
+ * for the current working directoty.
+ * @return a <code>Iterator</code> of files or <code>null</code> if the
+ * command failed.
+ * @throws IOException if an error occurred during the transmission
+ * @see #setDirParser(FtpDirParser)
+ * @see #changeDirectory(String)
+ */
+ public Iterator<FtpDirEntry> listFiles(String path) throws sun.net.ftp.FtpProtocolException, IOException {
+ Socket s = null;
+ BufferedReader sin = null;
+ try {
+ s = openDataConnection(path == null ? "MLSD" : "MLSD " + path);
+ } catch (sun.net.ftp.FtpProtocolException FtpException) {
+ // The server doesn't understand new MLSD command, ignore and fall
+ // back to LIST
+ }
+
+ if (s != null) {
+ sin = new BufferedReader(new InputStreamReader(s.getInputStream()));
+ return new FtpFileIterator(mlsxParser, sin);
+ } else {
+ s = openDataConnection(path == null ? "LIST" : "LIST " + path);
+ if (s != null) {
+ sin = new BufferedReader(new InputStreamReader(s.getInputStream()));
+ return new FtpFileIterator(parser, sin);
+ }
+ }
+ return null;
+ }
+
+ private boolean sendSecurityData(byte[] buf) throws IOException {
+ String s = Base64.getMimeEncoder().encodeToString(buf);
+ return issueCommand("ADAT " + s);
+ }
+
+ private byte[] getSecurityData() {
+ String s = getLastResponseString();
+ if (s.substring(4, 9).equalsIgnoreCase("ADAT=")) {
+ // Need to get rid of the leading '315 ADAT='
+ // and the trailing newline
+ return Base64.getMimeDecoder().decode(s.substring(9, s.length() - 1));
+ }
+ return null;
+ }
+
+ /**
+ * Attempts to use Kerberos GSSAPI as an authentication mechanism with the
+ * ftp server. This will issue an <code>AUTH GSSAPI</code> command, and if
+ * it is accepted by the server, will followup with <code>ADAT</code>
+ * command to exchange the various tokens until authentification is
+ * successful. This conforms to Appendix I of RFC 2228.
+ *
+ * @return <code>true</code> if authentication was successful.
+ * @throws IOException if an error occurs during the transmission.
+ */
+ public sun.net.ftp.FtpClient useKerberos() throws sun.net.ftp.FtpProtocolException, IOException {
+ /*
+ * Comment out for the moment since it's not in use and would create
+ * needless cross-package links.
+ *
+ issueCommandCheck("AUTH GSSAPI");
+ if (lastReplyCode != FtpReplyCode.NEED_ADAT)
+ throw new sun.net.ftp.FtpProtocolException("Unexpected reply from server");
+ try {
+ GSSManager manager = GSSManager.getInstance();
+ GSSName name = manager.createName("SERVICE:ftp@"+
+ serverAddr.getHostName(), null);
+ GSSContext context = manager.createContext(name, null, null,
+ GSSContext.DEFAULT_LIFETIME);
+ context.requestMutualAuth(true);
+ context.requestReplayDet(true);
+ context.requestSequenceDet(true);
+ context.requestCredDeleg(true);
+ byte []inToken = new byte[0];
+ while (!context.isEstablished()) {
+ byte[] outToken
+ = context.initSecContext(inToken, 0, inToken.length);
+ // send the output token if generated
+ if (outToken != null) {
+ if (sendSecurityData(outToken)) {
+ inToken = getSecurityData();
+ }
+ }
+ }
+ loggedIn = true;
+ } catch (GSSException e) {
+
+ }
+ */
+ return this;
+ }
+
+ /**
+ * Returns the Welcome string the server sent during initial connection.
+ *
+ * @return a <code>String</code> containing the message the server
+ * returned during connection or <code>null</code>.
+ */
+ public String getWelcomeMsg() {
+ return welcomeMsg;
+ }
+
+ /**
+ * Returns the last reply code sent by the server.
+ *
+ * @return the lastReplyCode
+ */
+ public FtpReplyCode getLastReplyCode() {
+ return lastReplyCode;
+ }
+
+ /**
+ * Returns the last response string sent by the server.
+ *
+ * @return the message string, which can be quite long, last returned
+ * by the server.
+ */
+ public String getLastResponseString() {
+ StringBuilder sb = new StringBuilder();
+ if (serverResponse != null) {
+ for (String l : serverResponse) {
+ if (l != null) {
+ sb.append(l);
+ }
+ }
+ }
+ return sb.toString();
+ }
+
+ /**
+ * Returns, when available, the size of the latest started transfer.
+ * This is retreived by parsing the response string received as an initial
+ * response to a RETR or similar request.
+ *
+ * @return the size of the latest transfer or -1 if either there was no
+ * transfer or the information was unavailable.
+ */
+ public long getLastTransferSize() {
+ return lastTransSize;
+ }
+
+ /**
+ * Returns, when available, the remote name of the last transfered file.
+ * This is mainly useful for "put" operation when the unique flag was
+ * set since it allows to recover the unique file name created on the
+ * server which may be different from the one submitted with the command.
+ *
+ * @return the name the latest transfered file remote name, or
+ * <code>null</code> if that information is unavailable.
+ */
+ public String getLastFileName() {
+ return lastFileName;
+ }
+
+ /**
+ * Attempts to switch to a secure, encrypted connection. This is done by
+ * sending the "AUTH TLS" command.
+ * <p>See <a href="http://www.ietf.org/rfc/rfc4217.txt">RFC 4217</a></p>
+ * If successful this will establish a secure command channel with the
+ * server, it will also make it so that all other transfers (e.g. a RETR
+ * command) will be done over an encrypted channel as well unless a
+ * {@link #reInit()} command or a {@link #endSecureSession()} command is issued.
+ *
+ * @return <code>true</code> if the operation was successful.
+ * @throws IOException if an error occurred during the transmission.
+ * @see #endSecureSession()
+ */
+ public sun.net.ftp.FtpClient startSecureSession() throws sun.net.ftp.FtpProtocolException, IOException {
+ if (!isConnected()) {
+ throw new sun.net.ftp.FtpProtocolException("Not connected yet", FtpReplyCode.BAD_SEQUENCE);
+ }
+ if (sslFact == null) {
+ try {
+ sslFact = (SSLSocketFactory) SSLSocketFactory.getDefault();
+ } catch (Exception e) {
+ throw new IOException(e.getLocalizedMessage());
+ }
+ }
+ issueCommandCheck("AUTH TLS");
+ Socket s = null;
+ try {
+ s = sslFact.createSocket(server, serverAddr.getHostName(), serverAddr.getPort(), true);
+ } catch (javax.net.ssl.SSLException ssle) {
+ try {
+ disconnect();
+ } catch (Exception e) {
+ }
+ throw ssle;
+ }
+ // Remember underlying socket so we can restore it later
+ oldSocket = server;
+ server = s;
+ try {
+ out = new PrintStream(new BufferedOutputStream(server.getOutputStream()),
+ true, encoding);
+ } catch (UnsupportedEncodingException e) {
+ throw new InternalError(encoding + "encoding not found", e);
+ }
+ in = new BufferedInputStream(server.getInputStream());
+
+ issueCommandCheck("PBSZ 0");
+ issueCommandCheck("PROT P");
+ useCrypto = true;
+ return this;
+ }
+
+ /**
+ * Sends a <code>CCC</code> command followed by a <code>PROT C</code>
+ * command to the server terminating an encrypted session and reverting
+ * back to a non crypted transmission.
+ *
+ * @return <code>true</code> if the operation was successful.
+ * @throws IOException if an error occurred during transmission.
+ * @see #startSecureSession()
+ */
+ public sun.net.ftp.FtpClient endSecureSession() throws sun.net.ftp.FtpProtocolException, IOException {
+ if (!useCrypto) {
+ return this;
+ }
+
+ issueCommandCheck("CCC");
+ issueCommandCheck("PROT C");
+ useCrypto = false;
+ // Restore previous socket and streams
+ server = oldSocket;
+ oldSocket = null;
+ try {
+ out = new PrintStream(new BufferedOutputStream(server.getOutputStream()),
+ true, encoding);
+ } catch (UnsupportedEncodingException e) {
+ throw new InternalError(encoding + "encoding not found", e);
+ }
+ in = new BufferedInputStream(server.getInputStream());
+
+ return this;
+ }
+
+ /**
+ * Sends the "Allocate" (ALLO) command to the server telling it to
+ * pre-allocate the specified number of bytes for the next transfer.
+ *
+ * @param size The number of bytes to allocate.
+ * @return <code>true</code> if the operation was successful.
+ * @throws IOException if an error occurred during the transmission.
+ */
+ public sun.net.ftp.FtpClient allocate(long size) throws sun.net.ftp.FtpProtocolException, IOException {
+ issueCommandCheck("ALLO " + size);
+ return this;
+ }
+
+ /**
+ * Sends the "Structure Mount" (SMNT) command to the server. This let the
+ * user mount a different file system data structure without altering his
+ * login or accounting information.
+ *
+ * @param struct a <code>String</code> containing the name of the
+ * structure to mount.
+ * @return <code>true</code> if the operation was successful.
+ * @throws IOException if an error occurred during the transmission.
+ */
+ public sun.net.ftp.FtpClient structureMount(String struct) throws sun.net.ftp.FtpProtocolException, IOException {
+ issueCommandCheck("SMNT " + struct);
+ return this;
+ }
+
+ /**
+ * Sends a SYST (System) command to the server and returns the String
+ * sent back by the server describing the operating system at the
+ * server.
+ *
+ * @return a <code>String</code> describing the OS, or <code>null</code>
+ * if the operation was not successful.
+ * @throws IOException if an error occurred during the transmission.
+ */
+ public String getSystem() throws sun.net.ftp.FtpProtocolException, IOException {
+ issueCommandCheck("SYST");
+ /*
+ * 215 UNIX Type: L8 Version: SUNOS
+ */
+ String resp = getResponseString();
+ // Get rid of the leading code and blank
+ return resp.substring(4);
+ }
+
+ /**
+ * Sends the HELP command to the server, with an optional command, like
+ * SITE, and returns the text sent back by the server.
+ *
+ * @param cmd the command for which the help is requested or
+ * <code>null</code> for the general help
+ * @return a <code>String</code> containing the text sent back by the
+ * server, or <code>null</code> if the command failed.
+ * @throws IOException if an error occurred during transmission
+ */
+ public String getHelp(String cmd) throws sun.net.ftp.FtpProtocolException, IOException {
+ issueCommandCheck("HELP " + cmd);
+ /**
+ *
+ * HELP
+ * 214-The following commands are implemented.
+ * USER EPRT STRU ALLO DELE SYST RMD MDTM ADAT
+ * PASS EPSV MODE REST CWD STAT PWD PROT
+ * QUIT LPRT RETR RNFR LIST HELP CDUP PBSZ
+ * PORT LPSV STOR RNTO NLST NOOP STOU AUTH
+ * PASV TYPE APPE ABOR SITE MKD SIZE CCC
+ * 214 Direct comments to ftp-bugs@jsn.
+ *
+ * HELP SITE
+ * 214-The following SITE commands are implemented.
+ * UMASK HELP GROUPS
+ * IDLE ALIAS CHECKMETHOD
+ * CHMOD CDPATH CHECKSUM
+ * 214 Direct comments to ftp-bugs@jsn.
+ */
+ Vector<String> resp = getResponseStrings();
+ if (resp.size() == 1) {
+ // Single line response
+ return resp.get(0).substring(4);
+ }
+ // on multiple lines answers, like the ones above, remove 1st and last
+ // line, concat the the others.
+ StringBuilder sb = new StringBuilder();
+ for (int i = 1; i < resp.size() - 1; i++) {
+ sb.append(resp.get(i).substring(3));
+ }
+ return sb.toString();
+ }
+
+ /**
+ * Sends the SITE command to the server. This is used by the server
+ * to provide services specific to his system that are essential
+ * to file transfer.
+ *
+ * @param cmd the command to be sent.
+ * @return <code>true</code> if the command was successful.
+ * @throws IOException if an error occurred during transmission
+ */
+ public sun.net.ftp.FtpClient siteCmd(String cmd) throws sun.net.ftp.FtpProtocolException, IOException {
+ issueCommandCheck("SITE " + cmd);
+ return this;
+ }
+}