proxyloginhandler.java

基于JXTA开发平台的下载软件开发源代码

/*
 * Created on Feb 1, 2005
 * Created by Alon Rohter
 * Copyright (C) 2004-2005 Aelitis, All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * This program 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 for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 * 
 * AELITIS, SAS au capital de 46,603.30 euros
 * 8 Allee Lenotre, La Grille Royale, 78600 Le Mesnil le Roi, France.
 *
 */

package com.aelitis.azureus.core.networkmanager.impl;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.util.ArrayList;

import org.gudy.azureus2.core3.config.COConfigurationManager;
import org.gudy.azureus2.core3.util.*;

import com.aelitis.azureus.core.networkmanager.*;
import com.aelitis.azureus.core.proxy.AEProxyFactory;


/**
 * Handles the process of proxy login/authentication/setup.
 */
public class ProxyLoginHandler {  
  
  public static final InetSocketAddress SOCKS_SERVER_ADDRESS;
  private static final String socks_version;
  private static final String socks_user;
  private static final String socks_password;
  

  static {
    boolean socks_same = COConfigurationManager.getBooleanParameter( "Proxy.Data.Same" );
    String socks_host = COConfigurationManager.getStringParameter( socks_same ? "Proxy.Host" : "Proxy.Data.Host" );
    int socks_port = 0;
    try{
      socks_port = Integer.parseInt( COConfigurationManager.getStringParameter( socks_same ? "Proxy.Port" : "Proxy.Data.Port" ) );
    }
    catch( Throwable e ){  Debug.printStackTrace(e);  }
    
    SOCKS_SERVER_ADDRESS = new InetSocketAddress( socks_host, socks_port );
    
    socks_version = COConfigurationManager.getStringParameter( "Proxy.Data.SOCKS.version" );
    socks_user  = COConfigurationManager.getStringParameter( socks_same ? "Proxy.Username" : "Proxy.Data.Username" );
    socks_password = COConfigurationManager.getStringParameter( socks_same ? "Proxy.Password" : "Proxy.Data.Password" );
  }
  
  
  private final TCPTransport proxy_connection;
  private final InetSocketAddress remote_address;  
  private final ProxyListener proxy_listener;
  
  private final String mapped_ip;
  private int socks5_handshake_phase = 0;
  private int socks5_address_length;
  
  private long read_start_time = 0;
  

  
  /**
   * Do proxy login.
   * @param proxy_connection transport connected to proxy server
   * @param remote_address address to proxy to
   * @param listener for proxy login success or faulure
   */
  public ProxyLoginHandler( TCPTransport _proxy_connection, InetSocketAddress _remote_address, ProxyListener listener ) {
    this.proxy_connection = _proxy_connection;
    this.remote_address = _remote_address;
    this.proxy_listener = listener;
       
    if ( remote_address.isUnresolved() || remote_address.getAddress() == null ){
      // deal with long "hostnames" that we get for, e.g., I2P destinations
    	mapped_ip = AEProxyFactory.getAddressMapper().internalise( remote_address.getHostName() ); 
    }
    else{
    	mapped_ip = remote_address.getAddress().getHostName();
    }
    
    if( socks_version.equals( "V4" ) ) {
      try{
        doSocks4Login( createSocks4Message() );
      }
      catch( Throwable t ) {
        Debug.out( t );
        proxy_listener.connectFailure( t );
      }
    }
    else if( socks_version.equals( "V4a" ) ) {
      try{
        doSocks4Login( createSocks4aMessage() );
      }
      catch( Throwable t ) {
        Debug.out( t );
        proxy_listener.connectFailure( t );
      }
    }
    else {  //"V5"
      doSocks5Login();
    }
    
  }


  private void doSocks4Login( final ByteBuffer[] data ) {
    try {
    	sendMessage( data[0] );  //send initial handshake to get things started
    	
      //register for read ops
      NetworkManager.getSingleton().getReadSelector().register( proxy_connection.getSocketChannel(), new VirtualChannelSelector.VirtualSelectorListener() {
        public boolean selectSuccess( VirtualChannelSelector selector, SocketChannel sc,Object attachment ) {
          try {
            boolean finished = readMessage( data[1] );
            
            if( finished ) {
              NetworkManager.getSingleton().getReadSelector().cancel( proxy_connection.getSocketChannel() );
              parseSocks4Reply( data[1] );  //will throw exception on error
              proxy_listener.connectSuccess();
            }
            else {
              NetworkManager.getSingleton().getReadSelector().resumeSelects( proxy_connection.getSocketChannel() );  //resume read ops
            }
          }
          catch( Throwable t ) {
          	//Debug.out( t );
            NetworkManager.getSingleton().getReadSelector().cancel( proxy_connection.getSocketChannel() );
            proxy_listener.connectFailure( t );
          }
          return true;
        }
        
        public void selectFailure( VirtualChannelSelector selector, SocketChannel sc,Object attachment, Throwable msg ) {
          Debug.out( msg );
          NetworkManager.getSingleton().getReadSelector().cancel( proxy_connection.getSocketChannel() );
          proxy_listener.connectFailure( msg );
        }
      }, null );
    }
    catch( Throwable t ) {
      Debug.out( t );
      NetworkManager.getSingleton().getReadSelector().cancel( proxy_connection.getSocketChannel() );
      proxy_listener.connectFailure( t );
    }
  }
  
  
  
  private void doSocks5Login() {
    try {
      final ArrayList data = new ArrayList(2);
      
      ByteBuffer[] header = createSocks5Message();
      data.add( header[0] );  //message
      data.add( header[1] );  //reply buff
      
      sendMessage( (ByteBuffer)data.get(0) );  //send initial handshake to get things started
      
      //register for read ops
      NetworkManager.getSingleton().getReadSelector().register( proxy_connection.getSocketChannel(), new VirtualChannelSelector.VirtualSelectorListener() {
        public boolean selectSuccess( VirtualChannelSelector selector, SocketChannel sc,Object attachment ) {
          try {
            boolean finished = readMessage( (ByteBuffer)data.get(1) );  
            
            if( finished ) {
              boolean done = parseSocks5Reply( (ByteBuffer)data.get(1) );  //will throw exception on error

              if( done ) {
                NetworkManager.getSingleton().getReadSelector().cancel( proxy_connection.getSocketChannel() );
                proxy_listener.connectSuccess();
              }
              else {
                ByteBuffer[] raw = createSocks5Message();
                data.set( 0, raw[0] );
                data.set( 1, raw[1] );                
                
                if( raw[0] != null )  sendMessage( raw[0] );
                NetworkManager.getSingleton().getReadSelector().resumeSelects( proxy_connection.getSocketChannel() );  //resume read ops
              }
            }
            else {
              NetworkManager.getSingleton().getReadSelector().resumeSelects( proxy_connection.getSocketChannel() );  //resume read ops
            }
          }
          catch( Throwable t ) {
            //Debug.out( t );
            NetworkManager.getSingleton().getReadSelector().cancel( proxy_connection.getSocketChannel() );
            proxy_listener.connectFailure( t );
          }
          return true;
        }
        
        public void selectFailure( VirtualChannelSelector selector, SocketChannel sc,Object attachment, Throwable msg ) {
          Debug.out( msg );
          NetworkManager.getSingleton().getReadSelector().cancel( proxy_connection.getSocketChannel() );
          proxy_listener.connectFailure( msg );
        }
      }, null );
    }
    catch( Throwable t ) {
      Debug.out( t );
      NetworkManager.getSingleton().getReadSelector().cancel( proxy_connection.getSocketChannel() );
      proxy_listener.connectFailure( t );
    }
  }
  
  
  
  
  private void parseSocks4Reply( ByteBuffer reply ) throws IOException {
      byte ver = reply.get();
      byte resp = reply.get();

      if( ver != 0 || resp != 90 ) {
        throw new IOException( "SOCKS4(a) connection declined [" +ver+ "/" + resp + "]" );
      }
  }
  
  
  
  

  private void sendMessage( ByteBuffer msg ) throws IOException {
    long start_time = SystemTime.getCurrentTime();
    
    while( msg.hasRemaining() ) {
      if( proxy_connection.write( new ByteBuffer[]{ msg }, 0, 1 ) < 1 ) {
        if( SystemTime.getCurrentTime() - start_time > 30*1000 ) {
          String error = "proxy handshake message send timed out after 30sec";
          Debug.out( error );
          throw new IOException( error );
        }
        
        try {   Thread.sleep( 10 );   }catch( Throwable t ) {t.printStackTrace();}
      }
    }
  }