natcheckerserver.java

java 文件下载器。可自定义

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space 
// Source File Name:   NatCheckerServer.java

package org.gudy.azureus2.core3.ipchecker.natchecker;

import com.aelitis.azureus.core.networkmanager.*;
import com.aelitis.azureus.core.networkmanager.impl.TransportHelper;
import com.aelitis.azureus.core.networkmanager.impl.http.HTTPNetworkManager;
import com.aelitis.azureus.core.networkmanager.impl.tcp.TCPNetworkManager;
import com.aelitis.azureus.core.peermanager.messaging.*;
import com.aelitis.azureus.core.peermanager.messaging.azureus.AZMessageDecoder;
import com.aelitis.azureus.core.peermanager.messaging.azureus.AZMessageEncoder;
import java.io.IOException;
import java.io.OutputStream;
import java.net.*;
import java.nio.ByteBuffer;
import java.util.HashMap;
import java.util.Map;
import org.gudy.azureus2.core3.logging.*;
import org.gudy.azureus2.core3.util.*;

public class NatCheckerServer extends AEThread
{

	private static final LogIDs LOGID;
	private static final String incoming_handshake = "NATCHECK_HANDSHAKE";
	private final InetAddress bind_ip;
	private boolean bind_ip_set;
	private final String check;
	private final boolean http_test;
	private ServerSocket server;
	private volatile boolean bContinue;
	private final boolean use_incoming_router;
	private com.aelitis.azureus.core.networkmanager.NetworkManager.ByteMatcher matcher;

	public NatCheckerServer(InetAddress _bind_ip, int _port, String _check, boolean _http_test)
		throws Exception
	{
		super("Nat Checker Server");
		bContinue = true;
		bind_ip = _bind_ip;
		check = _check;
		http_test = _http_test;
		if (http_test)
		{
			HTTPNetworkManager net_man = HTTPNetworkManager.getSingleton();
			if (net_man.isHTTPListenerEnabled())
				use_incoming_router = _port == net_man.getHTTPListeningPortNumber();
			else
				use_incoming_router = false;
			if (use_incoming_router && !net_man.isEffectiveBindAddress(bind_ip))
			{
				net_man.setExplicitBindAddress(bind_ip);
				bind_ip_set = true;
			}
		} else
		{
			TCPNetworkManager net_man = TCPNetworkManager.getSingleton();
			if (net_man.isTCPListenerEnabled())
				use_incoming_router = _port == net_man.getTCPListeningPortNumber();
			else
				use_incoming_router = false;
			if (use_incoming_router)
			{
				if (!net_man.isEffectiveBindAddress(bind_ip))
				{
					net_man.setExplicitBindAddress(bind_ip);
					bind_ip_set = true;
				}
				matcher = new com.aelitis.azureus.core.networkmanager.NetworkManager.ByteMatcher() {

					final NatCheckerServer this$0;

					public int matchThisSizeOrBigger()
					{
						return maxSize();
					}

					public int maxSize()
					{
						return "NATCHECK_HANDSHAKE".getBytes().length;
					}

					public int minSize()
					{
						return maxSize();
					}

					public Object matches(TransportHelper transport, ByteBuffer to_compare, int port)
					{
						int old_limit = to_compare.limit();
						to_compare.limit(to_compare.position() + maxSize());
						boolean matches = to_compare.equals(ByteBuffer.wrap("NATCHECK_HANDSHAKE".getBytes()));
						to_compare.limit(old_limit);
						return matches ? "" : null;
					}

					public Object minMatches(TransportHelper transport, ByteBuffer to_compare, int port)
					{
						return matches(transport, to_compare, port);
					}

					public byte[][] getSharedSecrets()
					{
						return null;
					}

					public int getSpecificPort()
					{
						return -1;
					}

			
			{
				this$0 = NatCheckerServer.this;
				super();
			}
				};
				NetworkManager.getSingleton().requestIncomingConnectionRouting(matcher, new com.aelitis.azureus.core.networkmanager.NetworkManager.RoutingListener() {

					final NatCheckerServer this$0;

					public void connectionRouted(NetworkConnection connection, Object routing_data)
					{
						if (Logger.isEnabled())
							Logger.log(new LogEvent(NatCheckerServer.LOGID, (new StringBuilder()).append("Incoming connection from [").append(connection).append("] successfully routed to NAT CHECKER").toString()));
						try
						{
							ByteBuffer msg = getMessage();
							Transport transport = connection.getTransport();
							long start = SystemTime.getCurrentTime();
							do
							{
								if (!msg.hasRemaining())
									break;
								transport.write(new ByteBuffer[] {
									msg
								}, 0, 1);
								if (msg.hasRemaining())
								{
									long now = SystemTime.getCurrentTime();
									if (now < start)
										start = now;
									else
									if (now - start > 30000L)
										throw new Exception("Timeout");
									Thread.sleep(50L);
								}
							} while (true);
						}
						catch (Throwable t)
						{
							Debug.out("Nat check write failed", t);
						}
						connection.close();
					}

					public boolean autoCryptoFallback()
					{
						return true;
					}

			
			{
				this$0 = NatCheckerServer.this;
				super();
			}
				}, new MessageStreamFactory() {

					final NatCheckerServer this$0;

					public MessageStreamEncoder createEncoder()
					{
						return new AZMessageEncoder(false);
					}

					public MessageStreamDecoder createDecoder()
					{
						return new AZMessageDecoder();
					}

			
			{
				this$0 = NatCheckerServer.this;
				super();
			}
				});
			}
			if (Logger.isEnabled())
				Logger.log(new LogEvent(LOGID, "NAT tester using central routing for server socket"));
		}
		if (!use_incoming_router)
			try
			{
				server = new ServerSocket();
				server.setReuseAddress(true);
				InetSocketAddress address;
				if (bind_ip != null)
					address = new InetSocketAddress(bind_ip, _port);
				else
					address = new InetSocketAddress(_port);
				server.bind(address);
				if (Logger.isEnabled())
					Logger.log(new LogEvent(LOGID, (new StringBuilder()).append("NAT tester server socket bound to ").append(address).toString()));
			}
			catch (Exception e)
			{
				Logger.log(new LogEvent(LOGID, "NAT tester failed to setup listener socket", e));
				throw e;
			}
	}

	protected ByteBuffer getMessage()
		throws IOException
	{
		Map map = new HashMap();
		map.put("check", check);
		byte map_bytes[] = BEncoder.encode(map);
		ByteBuffer msg = ByteBuffer.allocate(4 + map_bytes.length);
		msg.putInt(map_bytes.length);
		msg.put(map_bytes);
		msg.flip();
		return msg;
	}

	public void runSupport()
	{
		while (bContinue) 
			try
			{
				if (use_incoming_router)
				{
					Thread.sleep(20L);
				} else
				{
					Socket sck = server.accept();
					sck.getOutputStream().write(getMessage().array());
					sck.close();
				}
			}
			catch (Exception e)
			{
				bContinue = false;
			}
	}

	public void stopIt()
	{
		bContinue = false;
		if (use_incoming_router)
		{
			if (http_test)
			{
				if (bind_ip_set)
					HTTPNetworkManager.getSingleton().clearExplicitBindAddress();
			} else
			{
				NetworkManager.getSingleton().cancelIncomingConnectionRouting(matcher);
				if (bind_ip_set)
					TCPNetworkManager.getSingleton().clearExplicitBindAddress();
			}
		} else
		if (server != null)
			try
			{
				server.close();
			}
			catch (Throwable t)
			{
				t.printStackTrace();
			}
	}

	static 
	{
		LOGID = LogIDs.NET;
	}

}