org/objectweb/proactive/core/ssh/SshTunnel.java

/* 
 * ################################################################
 * 
 * ProActive: The Java(TM) library for Parallel, Distributed, 
 *            Concurrent computing with Security and Mobility
 * 
 * Copyright (C) 1997-2007 INRIA/University of Nice-Sophia Antipolis
 * Contact: proactive@objectweb.org
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or any later version.
 *  
 * This library 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
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA
 *  
 *  Initial developer(s):               The ProActive Team
 *                        http://www.inria.fr/oasis/ProActive/contacts.html
 *  Contributor(s): 
 * 
 * ################################################################
 */ 
package org.objectweb.proactive.core.ssh;

import java.io.IOException;
import java.net.InetAddress;
import java.util.Random;

import org.apache.log4j.Logger;
import org.objectweb.proactive.core.ssh.SshParameters;
import org.objectweb.proactive.core.util.log.Loggers;
import org.objectweb.proactive.core.util.log.ProActiveLogger;

import com.jcraft.jsch.*;


public class SshTunnel {
    static Logger logger = ProActiveLogger.getLogger(Loggers.SSH);
    private static Random _random = new Random();
    static private int lastTriedPort = _random.nextInt(65536-1024)+1024;
    private int _localPort;
    private Session _session;
    private String _username;
    private String _distantHost;
    private String _sshPort;
    private int _distantPort;

    public SshTunnel(String distantHost, int distantPort)
        throws IOException {
        JSchSingleton.acquireLock();
        try {
            String username = SshParameters.getSshUsername(distantHost);
            String sshPort = SshParameters.getSshPort();
            Session session;
            try {
                session = JSchSingleton.getSession(username, distantHost,
                        sshPort);
            } catch (IOException e) {
                throw new IOException("SSH tunnel failed: 127.0.0.1 -->" +
                    distantHost + ":" + distantPort + "for " + username);
            }
            
            /*
             * We are under JSchSingle lock. lastTriedPort will not change until we release it.
             *
             * Try to find a free port by looping until we find a free port.
             */ 
            int lport;
            for (
                        // Start search at the last allocated port
                        lport = lastTriedPort==65535 ? 1024 : lastTriedPort+1;
                        // No free port found
                        lport != lastTriedPort;
                        lport = lport==65535 ? 1024 : lport+1) {
                                        
                try {
                    session.setPortForwardingL("127.0.0.1", lport, distantHost,
                        distantPort);
                    _session = session;
                    _localPort = lport;
                    _username = username;
                    _distantHost = distantHost;
                    _distantPort = distantPort;
                    _sshPort = sshPort;
                    break;
                } catch (JSchException e) {
                    // Port probably in use...
                        logger.info("Please ignore the previous line. Everithing is ok; JSch is just a bit too verbose");
                }
                
                
            }
            
            if (lport == lastTriedPort) {
                throw new IOException(
                    "SSH tunnel failed (could not allocate port number): 127.0.0.1 -->" +
                    distantHost + ":" + distantPort);
            }
            
            lastTriedPort = lport;
        } catch (IOException e) {
                throw e;
        } finally {
            JSchSingleton.releaseLock();
        }
    }

    public void realClose() throws Exception {
        JSchSingleton.acquireLock();
        try {
            logger.debug("close Tunnel for port " + _localPort);
            JSchSingleton.flushMaybe(_username, _distantHost, _sshPort,
                _localPort);
            _username = null;
            _distantHost = null;
            _distantPort = 0;
            _sshPort = null;
            _session = null;
            _localPort = 0;
        } catch (Exception e) {
            throw e;
        } finally {
            JSchSingleton.releaseLock();
        }
    }

    public int getPort() {
        return _localPort;
    }

    public InetAddress getInetAddress() throws java.net.UnknownHostException {
        return InetAddress.getByName(_distantHost);
    }

    public String getDistantHost() {
        return _distantHost;
    }

    public int getDistantPort() {
        return _distantPort;
    }
}

---