mreye.java

httptunnel.jar httptunnel java 源码

package net.jumperz.app.httptunnel.MREYE;

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

public final class MREYE
{
private MThreadPool threadPool;
private boolean encryptData;
private File configFile;
private Properties prop;
private int port;
private String host;
private MResponseManager responseManager;
private MSessionManager sessionManager;
private String targetHost;
private int targetPort;

private static int threadCount;
private static MREYE instance;
private static String configFileName = "reye.conf";
//-------------------------------------------------------------------------------------
public static final synchronized MREYE getInstance()
{
return instance;
}
//-------------------------------------------------------------------------------------
public static void main( String[] args )
throws Exception
{
if( args.length == 1 )
	{
	instance = new MREYE( args[ 0 ] );
	instance.start();
	}
else
	{
	System.out.println( "Usage: java net.jumperz.app.MREYE.MREYE [ CONFIG_FILE ]" );	
	return;
	}
}
//-------------------------------------------------------------------------------------
private MREYE( String configFileName )
throws Exception
{
instance = this;
configFile = new File( configFileName );
loadConfig();
threadPool = new MThreadPool( threadCount );
//MCipher.getInstance();
responseManager = MResponseManager.getInstance();
sessionManager  = MSessionManager.getInstance();

MTimer timer = new MTimer( MResponseManager.INTERVAL );
MTimerObserver observer = new MTimerObserver();
timer.register1( observer );
threadPool.addCommand( timer );
}
//-----------------------------------------------------------------------
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();
MResponse.encryptData	= encryptData;
targetHost		= prop.getProperty( "targetHost" );
targetPort		= Integer.parseInt( prop.getProperty( "targetPort" ) );
MCipher.keyFileName	= prop.getProperty( "keyFileName" );
host			= prop.getProperty( "host", "" );
}
//-------------------------------------------------------------------------------------
private void start()
{
MMultiAcceptor acceptor = null;
if( host.equals( "" ) )
	{
	acceptor = new MMultiAcceptor( port );	
	}
else
	{
	acceptor = new MMultiAcceptor( host, port );
	}
MAcceptorObserver observer = new MAcceptorObserver( acceptor );
acceptor.register1( observer );
threadPool.addCommand( acceptor );
}
//-------------------------------------------------------------------------------------
public final void exit()
{
threadPool.stop();
System.exit( 0 );
}
//-------------------------------------------------------------------------------------
public final void recvRequest( Socket socket )
{
MRequestReceiver receiver = new MRequestReceiver( socket );
MRequestReceiverObserver observer = new MRequestReceiverObserver( receiver );
receiver.register1( observer );
threadPool.addCommand( receiver );
}
//-------------------------------------------------------------------------------------
public final void processRequest( MHttpRequest request, Socket socket )
{
try
	{
	if( request.getMethodType() != MHttpRequest.POST )
		{
		return;
		}
	
	byte[] body = null;
	byte[] tmpBodyBuffer = MStreamUtil.streamToBytes( request.getBodyInputStream() );
	
	if( encryptData )
		{
		body = MCipher.getInstance().decrypt( tmpBodyBuffer );
		}
	else
		{
		body = tmpBodyBuffer;
		}
	
	MTunnelData tunnelData = new MTunnelData( body );
	int method = tunnelData.getMethod();
	String sessionName = tunnelData.getSessionName();
	
	if( method == MTunnelData.OPEN )
		{
		MSession session;
		synchronized( sessionManager )
			{
			if( sessionManager.sessionExists( sessionName ) )
				{
				session =  sessionManager.getSession( sessionName );
				}
			else
				{
				session = new MSession( tunnelData.getSessionName() );
				sessionManager.putSession( session );
				}
			}
		connect( session );
		}
	else if( method == MTunnelData.SEND
	      || method == MTunnelData.CLOSE
	       )
		{
		MSession session;
		synchronized( sessionManager )
			{
			if( sessionManager.sessionExists( tunnelData.getSessionName() ) )
				{
				session = sessionManager.getSession( tunnelData.getSessionName() );
				}
			else
				{
				session = new MSession( tunnelData.getSessionName() );	
				sessionManager.putSession( session );
				}
			}
		session.putData( tunnelData );
		checkData( session );
		}
	else if( method == MTunnelData.NOOP )
		{
		//no operation
		}
	responseManager.addSocket( socket );
	}
catch( Exception e )
	{
	e.printStackTrace();
	}
}
//-------------------------------------------------------------------------------------
public final void connect( MSession session )
{
MConnector connector = new MConnector( targetHost, targetPort );
MConnectorObserver observer = new MConnectorObserver( connector, session );
connector.register1( observer );
threadPool.addCommand( connector );
}
//-------------------------------------------------------------------------------------
public final void startSession( MSession session )
{
try
	{
	MByteReceiver receiver = new MByteReceiver( session.getSocket().getInputStream() );
	MReceiverObserver observer = new MReceiverObserver( receiver, session );
	receiver.register1( observer );
	threadPool.addCommand( receiver );
	}
catch( IOException e )
	{
	endSession( session );
	}
}
//-------------------------------------------------------------------------------------
public final void checkNextData( MSession session )
throws IOException
{
session.clearBusy();
checkData( session );
}
//-------------------------------------------------------------------------------------
public final 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 serverSender = new MSender( outStream, tunnelData.getBuffer() );
		MServerSenderObserver observer = new MServerSenderObserver( serverSender, session );
		serverSender.register1( observer );
		threadPool.addCommand( serverSender );
		}
	else if( tunnelData.getMethod() == MTunnelData.CLOSE )
		{
		session.close();
		endLocalSession( session );
		}
	}
}
//-------------------------------------------------------------------------------------
public final void endLocalSession( MSession session )
{
Socket socket = session.getSocket();
if( socket != null )
	{
	if( !socket.isClosed() )
		{
		try
			{
			socket.close();
			}
		catch( IOException e )
			{
			}
		}
	}
sessionManager.removeSession( session );
}
//-------------------------------------------------------------------------------------
public final void endRemoteSession( MSession session )
{
MTunnelData tunnelData = new MTunnelData();
tunnelData.setMethod( MTunnelData.CLOSE );
tunnelData.setSessionName( session.getSessionName() );
tunnelData.setSequence( session.getSequence() );
tunnelData.setBuffer( "".getBytes() );

responseManager.putResponse( new MResponse( tunnelData ) );
}
//-------------------------------------------------------------------------------------
public final void endSession( MSession session )
{
endRemoteSession( session );
endLocalSession( session );
}
//-------------------------------------------------------------------------------------
public final void createResponse( 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 );

responseManager.putResponse( new MResponse( tunnelData ) );
}
//----------------------------------------------------------------------------------------------
public final void sendNOOP( Socket socket )
{
try
	{
	MTunnelData tunnelData = new MTunnelData();
	tunnelData.setMethod( MTunnelData.NOOP );
	MResponse response = new MResponse( tunnelData );
	MSender noopSender = new MSender( socket.getOutputStream(), response.toByteArray() );
	MNoopSenderObserver observer = new MNoopSenderObserver( noopSender, socket );
	noopSender.register1( observer );
	threadPool.addCommand( noopSender );
	}
catch( Exception e )
	{
	e.printStackTrace();
	}
}
//-------------------------------------------------------------------------------------
public final void sendResponse( Socket socket, MResponse response )
{
try
	{
	MSender responseSender = new MSender( socket.getOutputStream(), response.toByteArray() );
	MResponseSenderObserver observer = new MResponseSenderObserver( responseSender, socket, response );
	responseSender.register1( observer );
	threadPool.addCommand( responseSender );
	}
catch( Exception e )
	{
	e.printStackTrace();
	String sessionName = response.getTunnelData().getSessionName();
	MSession session = sessionManager.getSession( sessionName );
	endLocalSession( session );
	}
}
//-------------------------------------------------------------------------------------
}