msession.java

httptunnel.jar httptunnel java 源码

package net.jumperz.app.MDoorman;

import net.jumperz.net.*;
import net.jumperz.util.*;
import net.jumperz.io.*;
import net.jumperz.security.*;
import java.net.*;
import java.io.*;
import java.util.*;
import java.util.regex.*;

public class MSession
extends MBaseSession
{
public static MThreadPool threadPool;

private MDoorman doorman;
private boolean filterMatches = false;
private BufferedInputStream cIn, sIn;
private OutputStream cOut, sOut;
private String host;
private int port;
private boolean isHeadRequest;
private boolean cKeepAlive, sKeepAlive;
private MPeer oldPeer, peer;
private Socket cSocket;
private MHttpRequest connectRequest;

Socket	sSocket;
private boolean isHttps = false;
// --------------------------------------------------------------------------------
public MSession()
{
	// !!!ONLY XMLDecoder can call this method!!!
init();
}
// --------------------------------------------------------------------------------
public MSession( BufferedInputStream cIn, OutputStream cOut, Socket cSocket )
throws IOException
{
this.cIn = cIn;
this.cOut = cOut;
this.cSocket = cSocket;
xmlFlag = false;

init();
}
// --------------------------------------------------------------------------------
public MSession( BufferedInputStream cIn, OutputStream cOut, BufferedInputStream sIn, OutputStream sOut, MPeer oldPeer, Socket cSocket, Socket sSocket )
{
this.cIn = cIn;
this.cOut = cOut;
this.sIn = sIn;
this.sOut = sOut;
this.oldPeer = oldPeer;
this.cSocket = cSocket;
this.sSocket = sSocket;
xmlFlag = false;

init();
}
//--------------------------------------------------------------------------------
public void setConnectRequest( MHttpRequest r )
{
connectRequest = r;
}
// --------------------------------------------------------------------------------
public String getStateString()
{
return stateString[ state ];
}
// --------------------------------------------------------------------------------
public void setSSocket( Socket sSocket )
{
this.sSocket = sSocket;
if( sSocket != null )
	{
	sSocketString = sSocket.toString();
	}
}
// --------------------------------------------------------------------------------
private void init()
{
time = new Date().toString();
doorman = MDoorman.getInstance();
if( cSocket != null )
	{
	cSocketString = cSocket.toString();
	}
if( sSocket != null )
	{
	sSocketString = sSocket.toString();
	}
}
// --------------------------------------------------------------------------------
public void setHttps()
{
isHttps = true;
}
// --------------------------------------------------------------------------------
public void start()
{
state = RQ_RCVNG;

MRequestReceiver receiver = new MRequestReceiver( cIn );
MRequestReceiverObserver2 observer = new MRequestReceiverObserver2( receiver, this, cSocket );
receiver.register1( observer );
threadPool.addCommand( receiver );
}
// --------------------------------------------------------------------------------
public void onRequestReceived( MHttpRequest request )
{
state = RQ_MODIFY;

method = request.getMethod();

if( isHttps )
	{
	host = peer.getHost();
	port = peer.getPort();
	if( port == 443 )
		{
		uri = "https://" + host + request.getUri();
		}
	else
		{
		uri = "https://" + host + ":" + Integer.toString( port ) + request.getUri();
		}
	/*
	if( doorman.useProxy )
		{
		host = doorman.proxyHost2;
		port = doorman.proxyPort2;
		}
	*/
	}
else
	{
	uri = request.getUri();
	MRequestUri requestUri = new MRequestUri( uri );
	if( doorman.useProxy )
		{
		host = doorman.proxyHost1;
		port = doorman.proxyPort1;
		}
	else
		{
		host = requestUri.getHost();
		port = requestUri.getPort();
		requestUri.setRelative();
		request.setUri( requestUri.toString() );
		}
	peer = new MPeer( host, port );	

		//reusing connection
	if( oldPeer != null )
		{
		if( !oldPeer.equals( peer ) )
			{
			closeServerSide();
			sIn = null;
			sOut = null;
			}
		}
	}

	//filter
List stringList = new ArrayList();
stringList.add( request.getRequestLine() );
stringList.addAll( request.getHeaderList() );
if( conditionMatches( doorman.filterList, stringList ) )
	{
	filterMatches = true;
	}

if( !doorman.useProxy )
	{
	if( request.headerExists( "Proxy-Connection" ) )
		{
		request.setHeaderValue( "Connection", request.getHeaderValue( "Proxy-Connection" ) );
		request.removeHeaderValue( "Proxy-Connection" );
		}
	}
cKeepAlive = request.isKeepAliveRequest();

	//TODO
request.removeHeaderValue( "Accept-Encoding" );

requestByte = request.toByteArray();

updateGui();

	//break
if( conditionMatches( doorman.getBreakList( MBreak.TYPE_REQUEST ), stringList ) 
&& filterMatches == false
 )
	{
	closeServerSide();
	sIn = null;
	sOut = null;
	sSocket = null;
	}
else
	{
	sendRequest();
	}
}
// --------------------------------------------------------------------------------
public void onResponseReceived( MHttpResponse response )
{
state = RS_MODIFY;

statusCode = Integer.toString( response.getStatusCode() );

if( doorman.useProxy )
	{
	sKeepAlive = response.isKeepAliveResponse( "Proxy-Connection" );
	}
else
	{
	sKeepAlive = response.isKeepAliveResponse();
	if( response.headerExists( "Connection" ) )
		{
		response.setHeaderValue( "Proxy-Connection", response.getHeaderValue( "Connection" ) );
		response.removeHeaderValue( "Connection" );
		}
	}

updateGui();

	//break
List stringList = new ArrayList();
stringList.add( response.getStatusLine() );
stringList.addAll( response.getHeaderList() );

setResponseByte( response.toByteArray() );

if( conditionMatches( doorman.getBreakList( MBreak.TYPE_RESPONSE ), stringList ) 
&& filterMatches == false 
  )
	{
	}
else
	{
	sendResponse();
	}
}
// --------------------------------------------------------------------------------
public void sendResponse()
{
state = RS_SNDNG;

MSender sender = new MSender( cOut, getResponseByte() );
MResponseSenderObserver observer = new MResponseSenderObserver( sender, this );
sender.register1( observer );
threadPool.addCommand( sender );

updateGui();
}
// --------------------------------------------------------------------------------
public void onResponseSent()
{
if( isHttps )
	{
	MSystemUtil.sleep( 100 );
	}
if( cKeepAlive && sKeepAlive )
	{
	MSession session = new MSession( cIn, cOut, sIn, sOut, new MPeer( host, port ), cSocket, sSocket );
	if( isHttps )
		{
		session.setHttps();
		session.setPeer( peer );
		}
	session.start();
	}
else
	{
	closeStreams();
	cleanUp();
	}

state = COMPLETED;

updateGui();
}
// --------------------------------------------------------------------------------
public void sendRequest()
{
state = RQ_SNDNG;

if( sIn == null )
	{
	connect();
	}
else
	{
	isHeadRequest = ( MStringUtil.byteArrayToString( requestByte, doorman.getEnc() ).indexOf( "HEAD" ) == 0 );
	MSender sender = new MSender( sOut, requestByte );
	MRequestSenderObserver observer = new MRequestSenderObserver( sender, this );
	sender.register1( observer );
	threadPool.addCommand( sender );
	}

updateGui();
}
// --------------------------------------------------------------------------------
private void connect()
{
state = S_CONNECTING;

MConnector connector = null;

if( isHttps )
	{
	if( doorman.useProxy )
		{
		setupConnectProxy();
		return;
		}
	else
		{
		connector = new MSslConnector( host, port );	
		}
	}
else
	{
	connector = new MConnector( host, port );
	}
MConnectorObserver observer = new MConnectorObserver( connector, this );
connector.register1( observer );
threadPool.addCommand( connector );

updateGui();
}
//--------------------------------------------------------------------------------
private void setupConnectProxy()
{
Socket socket1 = null;
Socket socket3 = null;
Socket socket4 = null;
ServerSocket socket2 = null;
try
	{
	socket1 = new Socket( doorman.proxyHost2, doorman.proxyPort2 );
	OutputStream out1 = socket1.getOutputStream();
	InputStream in1 = socket1.getInputStream();

	out1.write( connectRequest.toByteArray() ); // send connect request
	BufferedInputStream bin1 = new BufferedInputStream( in1 );
	MHttpResponse connectResponse = new MHttpResponse( bin1, true );
	if( connectResponse.getStatusCode() != 200 )
		{
		errorClose();
		return;
		}
	
	socket2 = new ServerSocket( 0, 1, InetAddress.getByName( "127.0.0.1" ) );
	int port2 = socket2.getLocalPort();
	socket3 = MSecurityUtil.getBogusSslSocket( "127.0.0.1", port2 );
	InputStream in3 = socket3.getInputStream();
	OutputStream out3 = socket3.getOutputStream();
	socket4 = socket2.accept();
	socket2.close();
	InputStream in4 = socket4.getInputStream();
	OutputStream out4 = socket4.getOutputStream();
	
	MStreamConnector streamConnector1 = new MStreamConnector( in1, out4 );
	MStreamConnector streamConnector2 = new MStreamConnector( in4, out1 );
//	MStreamConnectorObserver streamConnectorObserver = new MStreamConnectorObserver( streamConnector2 );
//	streamConnectorObserver.addSocket( socket1 );
//	streamConnectorObserver.addSocket( socket3 );
//	streamConnectorObserver.addSocket( socket4 );
//	streamConnector2.register1( streamConnectorObserver );

	MThreadPool threadPool = MDoorman.getInstance().threadPool;
	threadPool.addCommand( streamConnector1 );
	threadPool.addCommand( streamConnector2 );
	
	setSSocket( socket3 );
	onServerConnected( new BufferedInputStream( in3 ), out3 );
	}
catch( IOException e )
	{
	errorClose();
	}
}
// --------------------------------------------------------------------------------
public void receiveResponse()
{
state = RS_RCVNG;

MResponseReceiver receiver = new MResponseReceiver( sIn, isHeadRequest );
MResponseReceiverObserver observer = new MResponseReceiverObserver( receiver, this );
receiver.register1( observer );
threadPool.addCommand( receiver );

updateGui();
}
// --------------------------------------------------------------------------------
public void onServerConnected( BufferedInputStream sIn, OutputStream sOut )
{
state = S_CONNECTED;

this.sIn = sIn;
this.sOut = sOut;

sendRequest();
}
// --------------------------------------------------------------------------------
private boolean conditionMatches( List conditionList, List stringList )
{
Iterator p = conditionList.iterator();
while( p.hasNext() )
	{
	MCondition condition = ( MCondition )p.next();
	if( condition.getEnabled() )
		{
		Pattern pattern = null;
		try
			{
			if( condition.isIgnoreCase() )
				{			
				pattern = Pattern.compile( condition.getPattern(), Pattern.CASE_INSENSITIVE );		
				}
			else
				{
				pattern = Pattern.compile( condition.getPattern() );	
				}			
			}
		catch( PatternSyntaxException e )
			{
			doorman.notifyException( e );
			return false;
			}
		Iterator q = stringList.iterator();
		while( q.hasNext() )
			{
			String input = ( String )q.next();
			if( pattern.matcher( input ).find() )
				{
				return true;
				}						
			}
		}
	}
return false;
}
// --------------------------------------------------------------------------------
private void cleanUp()
{
//request = null;
cIn = null;
cOut = null;
//response = null;
sIn = null;
sOut = null;
}
// --------------------------------------------------------------------------------
public void errorClose()
{
closeStreams();

state = ERROR;
updateGui();
}
// --------------------------------------------------------------------------------
private void closeStreams()
{
closeClientSide();
closeServerSide();
}
// --------------------------------------------------------------------------------
private void closeClientSide()
{
MStreamUtil.closeStream( cIn );
MStreamUtil.closeStream( cOut );
MSystemUtil.closeSocket( cSocket );
}
// --------------------------------------------------------------------------------
public void closeServerSide()
{
MStreamUtil.closeStream( sIn );
MStreamUtil.closeStream( sOut );
MSystemUtil.closeSocket( sSocket );
}
// --------------------------------------------------------------------------------
public void setHost( String host )
{
this.host = host;
}
// --------------------------------------------------------------------------------
public void setPort( int port )
{
this.port = port;
}
// --------------------------------------------------------------------------------
public void setPeer( MPeer p )
{
this.peer = p;
host = p.getHost();
port = p.getPort();
}
// --------------------------------------------------------------------------------
private void updateGui()
{
if( !filterMatches )
	{
	doorman.updateGui( this );
	}
}
// --------------------------------------------------------------------------------
}