    001/*
    002 * Licensed to the Apache Software Foundation (ASF) under one or more
    003 * contributor license agreements.  See the NOTICE file distributed with
    004 * this work for additional information regarding copyright ownership.
    005 * The ASF licenses this file to You under the Apache License, Version 2.0
    006 * (the "License"); you may not use this file except in compliance with
    007 * the License.  You may obtain a copy of the License at
    008 *
    009 *      http://www.apache.org/licenses/LICENSE-2.0
    010 *
    011 * Unless required by applicable law or agreed to in writing, software
    012 * distributed under the License is distributed on an "AS IS" BASIS,
    013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014 * See the License for the specific language governing permissions and
    015 * limitations under the License.
    016 */
    017
    018package org.apache.commons.net.ftp;
    019
    020import java.io.BufferedReader;
    021import java.io.IOException;
    022import java.io.InputStream;
    023import java.io.InputStreamReader;
    024import java.io.OutputStream;
    025import java.io.UnsupportedEncodingException;
    026import java.net.Inet6Address;
    027import java.net.Socket;
    028import java.net.SocketException;
    029import java.util.ArrayList;
    030import java.util.List;
    031
    032import org.apache.commons.net.util.Base64;
    033
    034/**
    035 * Experimental attempt at FTP client that tunnels over an HTTP proxy connection.
    036 *
    037 * @since 2.2
    038 */
    039public class FTPHTTPClient extends FTPClient {
    040    private final String proxyHost;
    041    private final int proxyPort;
    042    private final String proxyUsername;
    043    private final String proxyPassword;
    044
    045    private static final byte[] CRLF={'\r', '\n'};
    046    private final Base64 base64 = new Base64();
    047
    048    private String tunnelHost; // Save the host when setting up a tunnel (needed for EPSV)
    049
    050    public FTPHTTPClient(String proxyHost, int proxyPort, String proxyUser, String proxyPass) {
    051        this.proxyHost = proxyHost;
    052        this.proxyPort = proxyPort;
    053        this.proxyUsername = proxyUser;
    054        this.proxyPassword = proxyPass;
    055        this.tunnelHost = null;
    056    }
    057
    058    public FTPHTTPClient(String proxyHost, int proxyPort) {
    059        this(proxyHost, proxyPort, null, null);
    060    }
    061
    062
    063    /**
    064     * {@inheritDoc}
    065     *
    066     * @throws IllegalStateException if connection mode is not passive
    067     * @deprecated (3.3) Use {@link #_openDataConnection_(FTPCmd, String)} instead
    068     */
    069    // Kept to maintain binary compatibility
    070    // Not strictly necessary, but Clirr complains even though there is a super-impl
    071    @Override
    072    @Deprecated
    073    protected Socket _openDataConnection_(int command, String arg)
    074    throws IOException {
    075        return super._openDataConnection_(command, arg);
    076    }
    077
    078    /**
    079     * {@inheritDoc}
    080     *
    081     * @throws IllegalStateException if connection mode is not passive
    082     * @since 3.1
    083     */
    084    @Override
    085    protected Socket _openDataConnection_(String command, String arg)
    086    throws IOException {
    087        //Force local passive mode, active mode not supported by through proxy
    088        if (getDataConnectionMode() != PASSIVE_LOCAL_DATA_CONNECTION_MODE) {
    089            throw new IllegalStateException("Only passive connection mode supported");
    090        }
    091
    092        final boolean isInet6Address = getRemoteAddress() instanceof Inet6Address;
    093        String passiveHost = null;
    094
    095        boolean attemptEPSV = isUseEPSVwithIPv4() || isInet6Address;
    096        if (attemptEPSV && epsv() == FTPReply.ENTERING_EPSV_MODE) {
    097            _parseExtendedPassiveModeReply(_replyLines.get(0));
    098            passiveHost = this.tunnelHost;
    099        } else {
    100            if (isInet6Address) {
    101                return null; // Must use EPSV for IPV6
    102            }
    103            // If EPSV failed on IPV4, revert to PASV
    104            if (pasv() != FTPReply.ENTERING_PASSIVE_MODE) {
    105                return null;
    106            }
    107            _parsePassiveModeReply(_replyLines.get(0));
    108            passiveHost = this.getPassiveHost();
    109        }
    110
    111        Socket socket = new Socket(proxyHost, proxyPort);
    112        InputStream is = socket.getInputStream();
    113        OutputStream os = socket.getOutputStream();
    114        tunnelHandshake(passiveHost, this.getPassivePort(), is, os);
    115        if ((getRestartOffset() > 0) && !restart(getRestartOffset())) {
    116            socket.close();
    117            return null;
    118        }
    119
    120        if (!FTPReply.isPositivePreliminary(sendCommand(command, arg))) {
    121            socket.close();
    122            return null;
    123        }
    124
    125        return socket;
    126    }
    127
    128    @Override
    129    public void connect(String host, int port) throws SocketException, IOException {
    130
    131        _socket_ = new Socket(proxyHost, proxyPort);
    132        _input_ = _socket_.getInputStream();
    133        _output_ = _socket_.getOutputStream();
    134        try {
    135            tunnelHandshake(host, port, _input_, _output_);
    136        }
    137        catch (Exception e) {
    138            IOException ioe = new IOException("Could not connect to " + host+ " using port " + port);
    139            ioe.initCause(e);
    140            throw ioe;
    141        }
    142        super._connectAction_();
    143    }
    144
    145    private void tunnelHandshake(String host, int port, InputStream input, OutputStream output) throws IOException,
    146    UnsupportedEncodingException {
    147        final String connectString = "CONNECT "  + host + ":" + port  + " HTTP/1.1";
    148        final String hostString = "Host: " + host + ":" + port;
    149
    150        this.tunnelHost = host;
    151        output.write(connectString.getBytes("UTF-8")); // TODO what is the correct encoding?
    152        output.write(CRLF);
    153        output.write(hostString.getBytes("UTF-8"));
    154        output.write(CRLF);
    155
    156        if (proxyUsername != null && proxyPassword != null) {
    157            final String auth = proxyUsername + ":" + proxyPassword;
    158            final String header = "Proxy-Authorization: Basic "
    159                + base64.encodeToString(auth.getBytes("UTF-8"));
    160            output.write(header.getBytes("UTF-8"));
    161        }
    162        output.write(CRLF);
    163
    164        List<String> response = new ArrayList<String>();
    165        BufferedReader reader = new BufferedReader(
    166                new InputStreamReader(input, getCharsetName())); // Java 1.6 can use getCharset()
    167
    168        for (String line = reader.readLine(); line != null
    169        && line.length() > 0; line = reader.readLine()) {
    170            response.add(line);
    171        }
    172
    173        int size = response.size();
    174        if (size == 0) {
    175            throw new IOException("No response from proxy");
    176        }
    177
    178        String code = null;
    179        String resp = response.get(0);
    180        if (resp.startsWith("HTTP/") && resp.length() >= 12) {
    181            code = resp.substring(9, 12);
    182        } else {
    183            throw new IOException("Invalid response from proxy: " + resp);
    184        }
    185
    186        if (!"200".equals(code)) {
    187            StringBuilder msg = new StringBuilder();
    188            msg.append("HTTPTunnelConnector: connection failed\r\n");
    189            msg.append("Response received from the proxy:\r\n");
    190            for (String line : response) {
    191                msg.append(line);
    192                msg.append("\r\n");
    193            }
    194            throw new IOException(msg.toString());
    195        }
    196    }
    197}
    198
    199