jschsession.java

SFTP Plug-in for Eclipse will add the SFTP support to Eclipse

        }
        attemptCount++;
        return result;
      }
      catch(OperationCanceledException e){
        return null;
      }
      catch(CVSException e){
        return null;
      }
    }

    /**
     * Callback to indicate that a connection is about to be attempted
     */
    public void aboutToConnect(){
      attemptCount=0;
      passwordChanged=false;
    }

    /**
     * Callback to indicate that a connection was made
     */
    public void connectionMade(){
      attemptCount=0;
      if(passwordChanged&&password!=null){
        // We were prompted for and returned a password so record it with the location
        location.setPassword(password);
      }
    }
  }

  public static boolean isAuthenticationFailure(JSchException ee){
    return ee.getMessage().equals("Auth fail"); //$NON-NLS-1$
  }

  static JSchSession getSession(ICVSRepositoryLocation location,
      String username, String password, String hostname, int port,
      IProgressMonitor monitor) throws JSchException{

    if(port==ICVSRepositoryLocation.USE_DEFAULT_PORT)
      port=getPort(location);

    IPreferenceStore store=CVSSSH2Plugin.getDefault().getPreferenceStore();
    String ssh_home=store.getString(KEY_SSH2HOME);
    String pkeys=store.getString(KEY_PRIVATEKEY);

    try{
      if(current_ssh_home==null||!current_ssh_home.equals(ssh_home)){
        loadKnownHosts();
        current_ssh_home=ssh_home;
      }

      if(ssh_home.length()==0)
        ssh_home=SSH_HOME_DEFAULT;

      if(!current_pkeys.equals(pkeys)){
        java.io.File file;
        String[] pkey=pkeys.split(","); //$NON-NLS-1$
        String[] _pkey=current_pkeys.split(","); //$NON-NLS-1$
        current_pkeys=""; //$NON-NLS-1$
        for(int i=0; i<pkey.length; i++){
          file=new java.io.File(pkey[i]);
          if(!file.isAbsolute()){
            file=new java.io.File(ssh_home, pkey[i]);
          }
          if(file.exists()){
            boolean notyet=true;
            for(int j=0; j<_pkey.length; j++){
              if(pkey[i].equals(_pkey[j])){
                notyet=false;
                break;
              }
            }
            if(notyet)
              jsch.addIdentity(file.getPath());
            if(current_pkeys.length()==0){
              current_pkeys=pkey[i];
            }
            else{
              current_pkeys+=(","+pkey[i]); //$NON-NLS-1$
            }
          }
        }
      }
    }
    catch(Exception e){
    }

    String key=getPoolKey(username, hostname, port);

    try{
      JSchSession jschSession=(JSchSession)pool.get(key);
      if(jschSession!=null&&!jschSession.getSession().isConnected()){
        pool.remove(key);
        jschSession=null;
      }

      if(jschSession==null){
        boolean useProxy=CVSProviderPlugin.getPlugin().isUseProxy();
        Proxy proxy=null;
        if(useProxy){
          String _type=CVSProviderPlugin.getPlugin().getProxyType();
          String _host=CVSProviderPlugin.getPlugin().getProxyHost();
          String _port=CVSProviderPlugin.getPlugin().getProxyPort();

          boolean useAuth=CVSProviderPlugin.getPlugin().isUseProxyAuth();
          String _user=""; //$NON-NLS-1$
          String _pass=""; //$NON-NLS-1$

          // Retrieve username and password from keyring.
          if(useAuth){
            _user=CVSProviderPlugin.getPlugin().getProxyUser();
            _pass=CVSProviderPlugin.getPlugin().getProxyPassword();
          }

          String proxyhost=_host+":"+_port; //$NON-NLS-1$
          if(_type.equals(CVSProviderPlugin.PROXY_TYPE_HTTP)){
            proxy=new ProxyHTTP(proxyhost);
            if(useAuth){
              ((ProxyHTTP)proxy).setUserPasswd(_user, _pass);
            }
          }
          else if(_type.equals(CVSProviderPlugin.PROXY_TYPE_SOCKS5)){
            proxy=new ProxySOCKS5(proxyhost);
            if(useAuth){
              ((ProxySOCKS5)proxy).setUserPasswd(_user, _pass);
            }
          }
          else{
            proxy=null;
          }
        }

        MyUserInfo ui=new MyUserInfo(username, password, location);
        UserInfoTimer wrapperUI=new UserInfoTimer(ui);
        ui.aboutToConnect();

        Session session=null;
        try{
          session=createSession(username, password, hostname, port,
              new JSchSession.ResponsiveSocketFacory(monitor), proxy, wrapperUI);
          String _password=wrapperUI.getPassword();
          if(location!=null&&_password!=null&&!_password.equals(password)){
            location.setPassword(_password);
          }
        }
        catch(JSchException e){
          if(isAuthenticationFailure(e)&&wrapperUI.hasPromptExceededTimeout()){
            // Try again since the previous prompt may have obtained the proper credentials from the user
            session=createSession(username, password, hostname, port,
                new JSchSession.ResponsiveSocketFacory(monitor), proxy,
                wrapperUI);
          }
          else{
            throw e;
          }
        }
        ui.connectionMade();
        JSchSession schSession=new JSchSession(session, location, wrapperUI);
        pool.put(key, schSession);
        return schSession;
      }
      else{
        return jschSession;
      }
    }
    catch(JSchException e){
      pool.remove(key);
      if(e.toString().indexOf("Auth cancel")!=-1){ //$NON-NLS-1$
        throw new OperationCanceledException();
      }
      throw e;
    }
  }

  private static Session createSession(String username, String password,
      String hostname, int port, SocketFactory socketFactory, Proxy proxy,
      UserInfo wrapperUI) throws JSchException{
    Session session=jsch.getSession(username, hostname, port);
    if(proxy!=null){
      session.setProxy(proxy);
    }
    session.setPassword(password);
    session.setUserInfo(wrapperUI);
    session.setSocketFactory(socketFactory);
    // This is where the server is contacted and authentication occurs
    try{
      session.connect();
    }
    catch(JSchException e){
      if(session.isConnected())
        session.disconnect();
      throw e;
    }
    return session;
  }

  private static String getPoolKey(String username, String hostname, int port){
    return username+"@"+hostname+":"+port; //$NON-NLS-1$ //$NON-NLS-2$
  }

  private static String getPoolKey(ICVSRepositoryLocation location){
    return location.getUsername()+"@"+location.getHost()+":"+getPort(location); //$NON-NLS-1$ //$NON-NLS-2$
  }

  private static int getPort(ICVSRepositoryLocation location){
    int port=location.getPort();
    if(port==ICVSRepositoryLocation.USE_DEFAULT_PORT)
      port=SSH_DEFAULT_PORT;
    return port;
  }

  static void loadKnownHosts(){
    IPreferenceStore store=CVSSSH2Plugin.getDefault().getPreferenceStore();
    String ssh_home=store.getString(KEY_SSH2HOME);

    if(ssh_home.length()==0)
      ssh_home=SSH_HOME_DEFAULT;

    try{
      java.io.File file;
      file=new java.io.File(ssh_home, "known_hosts"); //$NON-NLS-1$
      jsch.setKnownHosts(file.getPath());
    }
    catch(Exception e){
    }
  }

  static void shutdown(){
    if(jsch!=null&&pool.size()>0){
      for(Enumeration e=pool.elements(); e.hasMoreElements();){
        JSchSession session=(JSchSession)(e.nextElement());
        try{
          session.getSession().disconnect();
        }
        catch(Exception ee){
        }
      }
      pool.clear();
    }
  }

  static JSch getJSch(){
    return jsch;
  }

  private JSchSession(Session session, ICVSRepositoryLocation location,
      UserInfo prompter){
    this.session=session;
    this.location=location;
    this.prompter=prompter;
  }

  public Session getSession(){
    return session;
  }

  public UserInfo getPrompter(){
    return prompter;
  }

  public boolean hasPromptExceededTimeout(){
    if(prompter instanceof UserInfoTimer){
      UserInfoTimer timer=(UserInfoTimer)prompter;
      if(!timer.isPrompting()){
        return timer.getLastDuration()>getTimeoutInMillis();
      }
    }
    return false;
  }

  public void dispose(){
    if(session.isConnected()){
      session.disconnect();
    }
    pool.remove(getPoolKey(location));
  }

  static Socket createSocket(final String host, final int port,
      IProgressMonitor monitor) throws UnknownHostException, IOException{

    // Start a thread to open a socket
    final Socket[] socket=new Socket[] {null};
    final Exception[] exception=new Exception[] {null};
    final Thread thread=new Thread(new Runnable(){
      public void run(){
        try{
          Socket newSocket=new Socket(host, port);
          synchronized(socket){
            if(Thread.interrupted()){
              // we we're either cancelled or timed out so just close the socket
              newSocket.close();
            }
            else{
              socket[0]=newSocket;
            }
          }
        }
        catch(UnknownHostException e){
          exception[0]=e;
        }
        catch(IOException e){
          exception[0]=e;
        }
      }
    });
    thread.start();

    // Wait the appropriate number of seconds
    int timeout=getTimeoutInMillis()/1000;
    if(timeout==0)
      timeout=DEFAULT_TIMEOUT;
    for(int i=0; i<timeout; i++){
      try{
        thread.join(1000);
      }
      catch(InterruptedException e){
      }
      synchronized(socket){
        if(monitor.isCanceled()){
          if(thread.isAlive()){
            thread.interrupt();
          }
          if(socket[0]!=null){
            socket[0].close();
          }
          if (monitor.isCanceled())
            throw new OperationCanceledException();
        }
      }
    }
    synchronized(socket){
      if(thread.isAlive()){
        thread.interrupt();
      }
    }
    if(exception[0]!=null){
      if(exception[0] instanceof UnknownHostException)
        throw (UnknownHostException)exception[0];
      else
        throw (IOException)exception[0];
    }
    if(socket[0]==null){
      throw new InterruptedIOException("timeout in connecting to "+host);
 /*     
      throw new InterruptedIOException(NLS.bind(CVSMessages.Util_timeout,
          new String[] {host}));
  */        
    }
    return socket[0];
  }
  
}