mleye.java

httptunnel.jar httptunnel java 源码

package net.jumperz.app.httptunnel.MLEYE;

import java.io.*;
import java.net.*;
import java.util.*;
import net.jumperz.net.*;
import net.jumperz.util.*;
import net.jumperz.app.httptunnel.*;

public final class MLEYE
{
private MThreadPool threadPool;
private boolean encryptData;
private int port;
private File configFile;
private Properties prop;
private MSessionManager sessionManager;

private static int threadCount;
private static MLEYE instance;
//-----------------------------------------------------------------------
public static final MLEYE getInstance()
{
return instance;
}
//-----------------------------------------------------------------------
public static void main( String[] args )
throws Exception
{
if( args.length == 1 )
	{
	instance = new MLEYE( args[ 0 ]);
	instance.start();
	}
else
	{
	System.out.println( "Usage: java net.jumperz.app.httptunnel.MLEYE.MLEYE [ CONFIG_FILE ]" );
	return;
	}
}
//-----------------------------------------------------------------------
public MLEYE( String configFileName )
throws Exception
{
configFile = new File( configFileName );
loadConfig();
threadPool = new MThreadPool( threadCount );
sessionManager = MSessionManager.getInstance();
threadPool.addCommand( MPoolingClient.getInstance() );
}
//-----------------------------------------------------------------------
private void loadConfig()
throws IOException
{
prop = new Properties();
prop.load( new FileInputStream( configFile ) );

port			= Integer.parseInt( prop.getProperty( "port" ) );
threadCount		= Integer.parseInt( prop.getProperty( "threadCount" ) );
encryptData		= Boolean.valueOf( prop.getProperty( "encryptData" ) ).booleanValue();
MHTunnelRequest.encryptData	= encryptData;
MHTunnelRequest.httpProxyHost	= prop.getProperty( "httpProxyHost" );
MHTunnelRequest.httpProxyPort	= Integer.parseInt( prop.getProperty( "httpProxyPort" ) );
MHTunnelRequest.rEyeHost	= prop.getProperty( "rEyeHost" );
MHTunnelRequest.rEyePort	= Integer.parseInt( prop.getProperty( "rEyePort" ) );
MCipher.keyFileName	= prop.getProperty( "keyFileName" );

	// basic proxy authentication
if( prop.containsKey( "proxyUser" )
 && prop.containsKey( "proxyPass" )
  )
	{
	String proxyUser = prop.getProperty( "proxyUser" );
	String proxyPass = prop.getProperty( "proxyPass" );
	
	String rawStr	= proxyUser + ":" + proxyPass;
	String cookie	= Base64.encodeString( rawStr );
	MHTunnelRequest.proxyAuthValue = "Basic " + cookie;
	}

}
//-----------------------------------------------------------------------
private void start()
{
MMultiAcceptor acceptor = new MMultiAcceptor( port );
MAcceptorObserver observer = new MAcceptorObserver( acceptor );
acceptor.register1( observer );
threadPool.addCommand( acceptor );
}
//-----------------------------------------------------------------------
public final void startSession( Socket in_socket )
{
try
	{
	MSession session = new MSession( in_socket );
	sessionManager.putSession( session );
	MPoolingClient.getInstance().resume();

	MTunnelData tunnelData = new MTunnelData();
	tunnelData.setMethod( MTunnelData.OPEN );
	tunnelData.setSessionName( session.getSessionName() );
	tunnelData.setBuffer( "".getBytes() );

		{
		MHTunnelRequest request = new MHTunnelRequest( tunnelData );
		MTunnelRequestSender sender = new MTunnelRequestSender( request );
		MSenderObserver observer = new MSenderObserver( sender );
		sender.register1( observer );
		threadPool.addCommand( sender );
		}
	
		{
		MByteReceiver receiver = new MByteReceiver( in_socket.getInputStream() );
		MReceiverObserver observer = new MReceiverObserver( receiver, session );
		receiver.register1( observer );
		threadPool.addCommand( receiver );
		}
	}
catch( Exception e )
	{
	e.printStackTrace();
	exit();
	}
}
//-----------------------------------------------------------------------
public final void sendDataToREye( byte[] buffer, int dataSize, MSession session )
{
MTunnelData tunnelData = new MTunnelData();
tunnelData.setMethod( MTunnelData.SEND );
tunnelData.setSequence( session.getSequence() );
tunnelData.setSessionName( session.getSessionName() );
byte[] w_buffer = new byte[ dataSize ];
System.arraycopy( buffer, 0, w_buffer, 0, dataSize );
tunnelData.setBuffer( w_buffer );

MHTunnelRequest request = new MHTunnelRequest( tunnelData );

MTunnelRequestSender sender = new MTunnelRequestSender( request );
MSenderObserver observer = new MSenderObserver( sender );
sender.register1( observer );
threadPool.addCommand( sender );
}
//-----------------------------------------------------------------------
public final void recvData( Socket socket )
{
MResponseReceiver receiver = new MResponseReceiver( socket );
MResponseReceiverObserver observer = new MResponseReceiverObserver( receiver );
receiver.register1( observer );
threadPool.addCommand( receiver );
}
//-----------------------------------------------------------------------
public final void sendDataToClient( MHttpResponse response )
{
try
	{
	MTunnelData tunnelData = null;
	byte[] bodyBuffer = MStreamUtil.streamToBytes( response.getBodyInputStream() );
	
	if( encryptData )
		{
		tunnelData = new MTunnelData( MCipher.getInstance().decrypt( bodyBuffer ) );
		}
	else
		{
		tunnelData = new MTunnelData( bodyBuffer );
		}

	int method = tunnelData.getMethod();
	String sessionName = tunnelData.getSessionName();

	if( method == MTunnelData.SEND
	 || method == MTunnelData.CLOSE
	  )
	  	{
		MSession session = null;
		synchronized( sessionManager )
			{
			if( sessionManager.sessionExists( sessionName ) )
				{
				session = sessionManager.getSession( sessionName );
				}
			}
		if( session != null )
			{
			session.putData( tunnelData );
			checkData( session );
			}

		}
	else if( method == MTunnelData.NOOP )
		{
		//no operation
		}
	}
catch( Exception e )
	{
	e.printStackTrace();
	}
}
//-----------------------------------------------------------------------
public final void checkNextData( MSession session )
throws IOException
{
session.clearBusy();
checkData( session );
}
//-----------------------------------------------------------------------
private void checkData( MSession session )
throws IOException
{
MTunnelData tunnelData = null;
synchronized( session )
	{
	if( session.isBusy() == false && session.hasNextTunnelData() )
		{
		tunnelData = session.getNextTunnelData();
		}
	}

if( tunnelData != null )
	{
	if( tunnelData.getMethod() == MTunnelData.SEND )
		{
		OutputStream outStream = session.getSocket().getOutputStream();
		MSender clientSender = new MSender( outStream, tunnelData.getBuffer() );
		MClientSenderObserver observer = new MClientSenderObserver( clientSender, session );
		clientSender.register1( observer );
		threadPool.addCommand( clientSender );
		}
	if( tunnelData.getMethod() == MTunnelData.CLOSE )
		{
		session.close();
		endLocalSession( session );
		}
	}
}
//-----------------------------------------------------------------------
public final void endAllSession( MSession session )
{
endRemoteSession( session );
endLocalSession( session );
}
//-----------------------------------------------------------------------
/**
 * Method endLocalSession.
 * @param session
 * Disconnect TCP connection
 * when failed to connect to HTTP proxy server
 * or disconnected by rEye
 */
public final void endLocalSession( MSession session )
{

Socket socket = session.getSocket();
if( !socket.isClosed() )
	{
	try
		{
		socket.close();
		}
	catch( IOException e )
		{
		e.printStackTrace();
		}
	}
sessionManager.removeSession( session );
}
//-----------------------------------------------------------------------
/**
 * Method endRemoteSession.
 * @param session 
 * Notify rEye the end of a session
 * when disconnected by a client application
 */
public final void endRemoteSession( MSession session )
{
MTunnelData tunnelData = new MTunnelData();
tunnelData.setMethod( MTunnelData.CLOSE );
tunnelData.setSequence( session.getSequence() );
tunnelData.setSessionName( session.getSessionName() );
byte[] w_buffer = "".getBytes();
tunnelData.setBuffer( w_buffer );

MHTunnelRequest request = new MHTunnelRequest( tunnelData );

MTunnelRequestSender sender = new MTunnelRequestSender( request );
MSenderObserver observer = new MSenderObserver( sender );
sender.register1( observer );
threadPool.addCommand( sender );
}
//-----------------------------------------------------------------------
public final void exit()
{
threadPool.stop();
System.exit( 0 );
}
//-----------------------------------------------------------------------
}