feat(jdk8): move files to new folder to avoid resources compiled.

jdkSrc/jdk8/sun/net/www/protocol/ftp/FtpURLConnection.java

@@ -0,0 +1,692 @@
+/*
+ * Copyright (c) 1994, 2025, 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.
+ */
+
+/**
+ * FTP stream opener.
+ */
+
+package sun.net.www.protocol.ftp;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.BufferedInputStream;
+import java.io.FilterInputStream;
+import java.io.FilterOutputStream;
+import java.io.FileNotFoundException;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.SocketPermission;
+import java.net.UnknownHostException;
+import java.net.InetSocketAddress;
+import java.net.URI;
+import java.net.Proxy;
+import java.net.ProxySelector;
+import java.util.StringTokenizer;
+import java.util.Iterator;
+import java.security.Permission;
+
+import sun.net.NetworkClient;
+import sun.net.util.IPAddressUtil;
+import sun.net.www.MessageHeader;
+import sun.net.www.MeteredStream;
+import sun.net.www.URLConnection;
+import sun.net.www.protocol.http.HttpURLConnection;
+import sun.net.ftp.FtpClient;
+import sun.net.ftp.FtpProtocolException;
+import sun.net.ProgressSource;
+import sun.net.ProgressMonitor;
+import sun.net.www.ParseUtil;
+import sun.security.action.GetPropertyAction;
+
+import static sun.net.util.ProxyUtil.copyProxy;
+
+/**
+ * This class Opens an FTP input (or output) stream given a URL.
+ * It works as a one shot FTP transfer :
+ * <UL>
+ * <LI>Login</LI>
+ * <LI>Get (or Put) the file</LI>
+ * <LI>Disconnect</LI>
+ * </UL>
+ * You should not have to use it directly in most cases because all will be handled
+ * in a abstract layer. Here is an example of how to use the class :
+ * <P>
+ * <code>URL url = new URL("ftp://ftp.sun.com/pub/test.txt");<p>
+ * UrlConnection con = url.openConnection();<p>
+ * InputStream is = con.getInputStream();<p>
+ * ...<p>
+ * is.close();</code>
+ *
+ * @see sun.net.ftp.FtpClient
+ */
+public class FtpURLConnection extends URLConnection {
+
+    // In case we have to use proxies, we use HttpURLConnection
+    HttpURLConnection http = null;
+    private Proxy instProxy;
+
+    InputStream is = null;
+    OutputStream os = null;
+
+    FtpClient ftp = null;
+    Permission permission;
+
+    String password;
+    String user;
+
+    String host;
+    String pathname;
+    String filename;
+    String fullpath;
+    int port;
+    static final int NONE = 0;
+    static final int ASCII = 1;
+    static final int BIN = 2;
+    static final int DIR = 3;
+    int type = NONE;
+    /* Redefine timeouts from java.net.URLConnection as we need -1 to mean
+     * not set. This is to ensure backward compatibility.
+     */
+    private int connectTimeout = NetworkClient.DEFAULT_CONNECT_TIMEOUT;;
+    private int readTimeout = NetworkClient.DEFAULT_READ_TIMEOUT;;
+
+    /**
+     * For FTP URLs we need to have a special InputStream because we
+     * need to close 2 sockets after we're done with it :
+     *  - The Data socket (for the file).
+     *   - The command socket (FtpClient).
+     * Since that's the only class that needs to see that, it is an inner class.
+     */
+    protected class FtpInputStream extends FilterInputStream {
+        FtpClient ftp;
+        FtpInputStream(FtpClient cl, InputStream fd) {
+            super(new BufferedInputStream(fd));
+            ftp = cl;
+        }
+
+        @Override
+        public void close() throws IOException {
+            super.close();
+            if (ftp != null) {
+                ftp.close();
+            }
+        }
+    }
+
+    /**
+     * For FTP URLs we need to have a special OutputStream because we
+     * need to close 2 sockets after we're done with it :
+     *  - The Data socket (for the file).
+     *   - The command socket (FtpClient).
+     * Since that's the only class that needs to see that, it is an inner class.
+     */
+    protected class FtpOutputStream extends FilterOutputStream {
+        FtpClient ftp;
+        FtpOutputStream(FtpClient cl, OutputStream fd) {
+            super(fd);
+            ftp = cl;
+        }
+
+        @Override
+        public void close() throws IOException {
+            super.close();
+            if (ftp != null) {
+                ftp.close();
+            }
+        }
+    }
+
+    static URL checkURL(URL u) throws IllegalArgumentException {
+        if (u != null) {
+            if (u.toExternalForm().indexOf('\n') > -1) {
+                Exception mfue = new MalformedURLException("Illegal character in URL");
+                throw new IllegalArgumentException(mfue.getMessage(), mfue);
+            }
+        }
+        String s = IPAddressUtil.checkAuthority(u);
+        if (s != null) {
+            Exception mfue = new MalformedURLException(s);
+            throw new IllegalArgumentException(mfue.getMessage(), mfue);
+        }
+        return u;
+    }
+
+    /**
+     * Creates an FtpURLConnection from a URL.
+     *
+     * @param   url     The <code>URL</code> to retrieve or store.
+     */
+    public FtpURLConnection(URL url) {
+        this(url, null);
+    }
+
+    /**
+     * Same as FtpURLconnection(URL) with a per connection proxy specified
+     */
+    FtpURLConnection(URL url, Proxy p) {
+        super(checkURL(url));
+        instProxy = p;
+        host = url.getHost();
+        port = url.getPort();
+        String userInfo = url.getUserInfo();
+
+        if (userInfo != null) { // get the user and password
+            int delimiter = userInfo.indexOf(':');
+            if (delimiter == -1) {
+                user = ParseUtil.decode(userInfo);
+                password = null;
+            } else {
+                user = ParseUtil.decode(userInfo.substring(0, delimiter++));
+                password = ParseUtil.decode(userInfo.substring(delimiter));
+            }
+        }
+    }
+
+    private void setTimeouts() {
+        if (ftp != null) {
+            if (connectTimeout >= 0) {
+                ftp.setConnectTimeout(connectTimeout);
+            }
+            if (readTimeout >= 0) {
+                ftp.setReadTimeout(readTimeout);
+            }
+        }
+    }
+
+    /**
+     * Connects to the FTP server and logs in.
+     *
+     * @throws  FtpLoginException if the login is unsuccessful
+     * @throws  FtpProtocolException if an error occurs
+     * @throws  UnknownHostException if trying to connect to an unknown host
+     */
+
+    public synchronized void connect() throws IOException {
+        if (connected) {
+            return;
+        }
+
+        Proxy p = null;
+        if (instProxy == null) { // no per connection proxy specified
+            /**
+             * Do we have to use a proxy?
+             */
+            ProxySelector sel = java.security.AccessController.doPrivileged(
+                    new java.security.PrivilegedAction<ProxySelector>() {
+                        public ProxySelector run() {
+                            return ProxySelector.getDefault();
+                        }
+                    });
+            if (sel != null) {
+                URI uri = sun.net.www.ParseUtil.toURI(url);
+                Iterator<Proxy> it = sel.select(uri).iterator();
+                while (it.hasNext()) {
+                    p = copyProxy(it.next());
+                    if (p == null || p == Proxy.NO_PROXY ||
+                        p.type() == Proxy.Type.SOCKS) {
+                        break;
+                    }
+                    if (p.type() != Proxy.Type.HTTP ||
+                            !(p.address() instanceof InetSocketAddress)) {
+                        sel.connectFailed(uri, p.address(), new IOException("Wrong proxy type"));
+                        continue;
+                    }
+                    // OK, we have an http proxy
+                    InetSocketAddress paddr = (InetSocketAddress) p.address();
+                    try {
+                        http = new HttpURLConnection(url, p);
+                        http.setDoInput(getDoInput());
+                        http.setDoOutput(getDoOutput());
+                        if (connectTimeout >= 0) {
+                            http.setConnectTimeout(connectTimeout);
+                        }
+                        if (readTimeout >= 0) {
+                            http.setReadTimeout(readTimeout);
+                        }
+                        http.connect();
+                        connected = true;
+                        return;
+                    } catch (IOException ioe) {
+                        sel.connectFailed(uri, paddr, ioe);
+                        http = null;
+                    }
+                }
+            }
+        } else { // per connection proxy specified
+            p = instProxy;
+            if (p.type() == Proxy.Type.HTTP) {
+                http = new HttpURLConnection(url, instProxy);
+                http.setDoInput(getDoInput());
+                http.setDoOutput(getDoOutput());
+                if (connectTimeout >= 0) {
+                    http.setConnectTimeout(connectTimeout);
+                }
+                if (readTimeout >= 0) {
+                    http.setReadTimeout(readTimeout);
+                }
+                http.connect();
+                connected = true;
+                return;
+            }
+        }
+
+        if (user == null) {
+            user = "anonymous";
+            String vers = java.security.AccessController.doPrivileged(
+                    new GetPropertyAction("java.version"));
+            password = java.security.AccessController.doPrivileged(
+                    new GetPropertyAction("ftp.protocol.user",
+                                          "Java" + vers + "@"));
+        }
+        try {
+            ftp = FtpClient.create();
+            if (p != null) {
+                ftp.setProxy(p);
+            }
+            setTimeouts();
+            if (port != -1) {
+                ftp.connect(new InetSocketAddress(host, port));
+            } else {
+                ftp.connect(new InetSocketAddress(host, FtpClient.defaultPort()));
+            }
+        } catch (UnknownHostException e) {
+            // Maybe do something smart here, like use a proxy like iftp.
+            // Just keep throwing for now.
+            throw e;
+        } catch (FtpProtocolException fe) {
+            if (ftp != null) {
+                try {
+                    ftp.close();
+                } catch (IOException ioe) {
+                    fe.addSuppressed(ioe);
+                }
+            }
+            throw new IOException(fe);
+        }
+        try {
+            ftp.login(user, password == null ? null : password.toCharArray());
+        } catch (sun.net.ftp.FtpProtocolException e) {
+            ftp.close();
+            // Backward compatibility
+            throw new sun.net.ftp.FtpLoginException("Invalid username/password");
+        }
+        connected = true;
+    }
+
+
+    /*
+     * Decodes the path as per the RFC-1738 specifications.
+     */
+    private void decodePath(String path) {
+        int i = path.indexOf(";type=");
+        if (i >= 0) {
+            String s1 = path.substring(i + 6, path.length());
+            if ("i".equalsIgnoreCase(s1)) {
+                type = BIN;
+            }
+            if ("a".equalsIgnoreCase(s1)) {
+                type = ASCII;
+            }
+            if ("d".equalsIgnoreCase(s1)) {
+                type = DIR;
+            }
+            path = path.substring(0, i);
+        }
+        if (path != null && path.length() > 1 &&
+                path.charAt(0) == '/') {
+            path = path.substring(1);
+        }
+        if (path == null || path.length() == 0) {
+            path = "./";
+        }
+        if (!path.endsWith("/")) {
+            i = path.lastIndexOf('/');
+            if (i > 0) {
+                filename = path.substring(i + 1, path.length());
+                filename = ParseUtil.decode(filename);
+                pathname = path.substring(0, i);
+            } else {
+                filename = ParseUtil.decode(path);
+                pathname = null;
+            }
+        } else {
+            pathname = path.substring(0, path.length() - 1);
+            filename = null;
+        }
+        if (pathname != null) {
+            fullpath = pathname + "/" + (filename != null ? filename : "");
+        } else {
+            fullpath = filename;
+        }
+    }
+
+    /*
+     * As part of RFC-1738 it is specified that the path should be
+     * interpreted as a series of FTP CWD commands.
+     * This is because, '/' is not necessarly the directory delimiter
+     * on every systems.
+     */
+    private void cd(String path) throws FtpProtocolException, IOException {
+        if (path == null || path.isEmpty()) {
+            return;
+        }
+        if (path.indexOf('/') == -1) {
+            ftp.changeDirectory(ParseUtil.decode(path));
+            return;
+        }
+
+        StringTokenizer token = new StringTokenizer(path, "/");
+        while (token.hasMoreTokens()) {
+            ftp.changeDirectory(ParseUtil.decode(token.nextToken()));
+        }
+    }
+
+    /**
+     * Get the InputStream to retreive the remote file. It will issue the
+     * "get" (or "dir") command to the ftp server.
+     *
+     * @return  the <code>InputStream</code> to the connection.
+     *
+     * @throws  IOException if already opened for output
+     * @throws  FtpProtocolException if errors occur during the transfert.
+     */
+    @Override
+    public InputStream getInputStream() throws IOException {
+        if (!connected) {
+            connect();
+        }
+
+        if (http != null) {
+            return http.getInputStream();
+        }
+
+        if (os != null) {
+            throw new IOException("Already opened for output");
+        }
+
+        if (is != null) {
+            return is;
+        }
+
+        MessageHeader msgh = new MessageHeader();
+
+        boolean isAdir = false;
+        try {
+            decodePath(url.getPath());
+            if (filename == null || type == DIR) {
+                ftp.setAsciiType();
+                cd(pathname);
+                if (filename == null) {
+                    is = new FtpInputStream(ftp, ftp.list(null));
+                } else {
+                    is = new FtpInputStream(ftp, ftp.nameList(filename));
+                }
+            } else {
+                if (type == ASCII) {
+                    ftp.setAsciiType();
+                } else {
+                    ftp.setBinaryType();
+                }
+                cd(pathname);
+                is = new FtpInputStream(ftp, ftp.getFileStream(filename));
+            }
+
+            /* Try to get the size of the file in bytes.  If that is
+            successful, then create a MeteredStream. */
+            try {
+                long l = ftp.getLastTransferSize();
+                msgh.add("content-length", Long.toString(l));
+                if (l > 0) {
+
+                    // Wrap input stream with MeteredStream to ensure read() will always return -1
+                    // at expected length.
+
+                    // Check if URL should be metered
+                    boolean meteredInput = ProgressMonitor.getDefault().shouldMeterInput(url, "GET");
+                    ProgressSource pi = null;
+
+                    if (meteredInput) {
+                        pi = new ProgressSource(url, "GET", l);
+                        pi.beginTracking();
+                    }
+
+                    is = new MeteredStream(is, pi, l);
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            /* do nothing, since all we were doing was trying to
+            get the size in bytes of the file */
+            }
+
+            if (isAdir) {
+                msgh.add("content-type", "text/plain");
+                msgh.add("access-type", "directory");
+            } else {
+                msgh.add("access-type", "file");
+                String ftype = guessContentTypeFromName(fullpath);
+                if (ftype == null && is.markSupported()) {
+                    ftype = guessContentTypeFromStream(is);
+                }
+                if (ftype != null) {
+                    msgh.add("content-type", ftype);
+                }
+            }
+        } catch (FileNotFoundException e) {
+            try {
+                cd(fullpath);
+                /* if that worked, then make a directory listing
+                and build an html stream with all the files in
+                the directory */
+                ftp.setAsciiType();
+
+                is = new FtpInputStream(ftp, ftp.list(null));
+                msgh.add("content-type", "text/plain");
+                msgh.add("access-type", "directory");
+            } catch (IOException ex) {
+                FileNotFoundException fnfe = new FileNotFoundException(fullpath);
+                if (ftp != null) {
+                    try {
+                        ftp.close();
+                    } catch (IOException ioe) {
+                        fnfe.addSuppressed(ioe);
+                    }
+                }
+                throw fnfe;
+            } catch (FtpProtocolException ex2) {
+                FileNotFoundException fnfe = new FileNotFoundException(fullpath);
+                if (ftp != null) {
+                    try {
+                        ftp.close();
+                    } catch (IOException ioe) {
+                        fnfe.addSuppressed(ioe);
+                    }
+                }
+                throw fnfe;
+            }
+        } catch (FtpProtocolException ftpe) {
+            if (ftp != null) {
+                try {
+                    ftp.close();
+                } catch (IOException ioe) {
+                    ftpe.addSuppressed(ioe);
+                }
+            }
+            throw new IOException(ftpe);
+        }
+        setProperties(msgh);
+        return is;
+    }
+
+    /**
+     * Get the OutputStream to store the remote file. It will issue the
+     * "put" command to the ftp server.
+     *
+     * @return  the <code>OutputStream</code> to the connection.
+     *
+     * @throws  IOException if already opened for input or the URL
+     *          points to a directory
+     * @throws  FtpProtocolException if errors occur during the transfert.
+     */
+    @Override
+    public OutputStream getOutputStream() throws IOException {
+        if (!connected) {
+            connect();
+        }
+
+        if (http != null) {
+            OutputStream out = http.getOutputStream();
+            // getInputStream() is neccessary to force a writeRequests()
+            // on the http client.
+            http.getInputStream();
+            return out;
+        }
+
+        if (is != null) {
+            throw new IOException("Already opened for input");
+        }
+
+        if (os != null) {
+            return os;
+        }
+
+        decodePath(url.getPath());
+        if (filename == null || filename.length() == 0) {
+            throw new IOException("illegal filename for a PUT");
+        }
+        try {
+            if (pathname != null) {
+                cd(pathname);
+            }
+            if (type == ASCII) {
+                ftp.setAsciiType();
+            } else {
+                ftp.setBinaryType();
+            }
+            os = new FtpOutputStream(ftp, ftp.putFileStream(filename, false));
+        } catch (FtpProtocolException e) {
+            throw new IOException(e);
+        }
+        return os;
+    }
+
+    String guessContentTypeFromFilename(String fname) {
+        return guessContentTypeFromName(fname);
+    }
+
+    /**
+     * Gets the <code>Permission</code> associated with the host & port.
+     *
+     * @return  The <code>Permission</code> object.
+     */
+    @Override
+    public Permission getPermission() {
+        if (permission == null) {
+            int urlport = url.getPort();
+            urlport = urlport < 0 ? FtpClient.defaultPort() : urlport;
+            String urlhost = this.host + ":" + urlport;
+            permission = new SocketPermission(urlhost, "connect");
+        }
+        return permission;
+    }
+
+    /**
+     * Sets the general request property. If a property with the key already
+     * exists, overwrite its value with the new value.
+     *
+     * @param   key     the keyword by which the request is known
+     *                  (e.g., "<code>accept</code>").
+     * @param   value   the value associated with it.
+     * @throws IllegalStateException if already connected
+     * @see #getRequestProperty(java.lang.String)
+     */
+    @Override
+    public void setRequestProperty(String key, String value) {
+        super.setRequestProperty(key, value);
+        if ("type".equals(key)) {
+            if ("i".equalsIgnoreCase(value)) {
+                type = BIN;
+            } else if ("a".equalsIgnoreCase(value)) {
+                type = ASCII;
+            } else if ("d".equalsIgnoreCase(value)) {
+                type = DIR;
+            } else {
+                throw new IllegalArgumentException(
+                        "Value of '" + key +
+                        "' request property was '" + value +
+                        "' when it must be either 'i', 'a' or 'd'");
+            }
+        }
+    }
+
+    /**
+     * Returns the value of the named general request property for this
+     * connection.
+     *
+     * @param key the keyword by which the request is known (e.g., "accept").
+     * @return  the value of the named general request property for this
+     *           connection.
+     * @throws IllegalStateException if already connected
+     * @see #setRequestProperty(java.lang.String, java.lang.String)
+     */
+    @Override
+    public String getRequestProperty(String key) {
+        String value = super.getRequestProperty(key);
+
+        if (value == null) {
+            if ("type".equals(key)) {
+                value = (type == ASCII ? "a" : type == DIR ? "d" : "i");
+            }
+        }
+
+        return value;
+    }
+
+    @Override
+    public void setConnectTimeout(int timeout) {
+        if (timeout < 0) {
+            throw new IllegalArgumentException("timeouts can't be negative");
+        }
+        connectTimeout = timeout;
+    }
+
+    @Override
+    public int getConnectTimeout() {
+        return (connectTimeout < 0 ? 0 : connectTimeout);
+    }
+
+    @Override
+    public void setReadTimeout(int timeout) {
+        if (timeout < 0) {
+            throw new IllegalArgumentException("timeouts can't be negative");
+        }
+        readTimeout = timeout;
+    }
+
+    @Override
+    public int getReadTimeout() {
+        return readTimeout < 0 ? 0 : readTimeout;
+    }
+}

jdkSrc/jdk8/sun/net/www/protocol/ftp/Handler.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 1994, 2025, 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.
+ */
+
+/*-
+ *      FTP stream opener
+ */
+
+package sun.net.www.protocol.ftp;
+
+import java.io.IOException;
+import java.net.URL;
+import java.net.Proxy;
+import static sun.net.util.ProxyUtil.copyProxy;
+
+/** open an ftp connection given a URL */
+public class Handler extends java.net.URLStreamHandler {
+
+    protected int getDefaultPort() {
+        return 21;
+    }
+
+    protected boolean equals(URL u1, URL u2) {
+        String userInfo1 = u1.getUserInfo();
+        String userInfo2 = u2.getUserInfo();
+        return super.equals(u1, u2) &&
+            (userInfo1 == null? userInfo2 == null: userInfo1.equals(userInfo2));
+    }
+
+    protected java.net.URLConnection openConnection(URL u)
+        throws IOException {
+        return openConnection(u, null);
+    }
+
+    protected java.net.URLConnection openConnection(URL u, Proxy proxy)
+        throws IOException {
+        return new FtpURLConnection(u, copyProxy(proxy));
+    }
+}