genericmessageconnectionimpl.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:   GenericMessageConnectionImpl.java

package org.gudy.azureus2.pluginsimpl.local.messaging;

import com.aelitis.azureus.core.nat.NATTraversalObserver;
import com.aelitis.azureus.core.nat.NATTraverser;
import com.aelitis.azureus.core.networkmanager.ConnectionEndpoint;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.util.*;
import org.gudy.azureus2.core3.util.Debug;
import org.gudy.azureus2.core3.util.DirectByteBuffer;
import org.gudy.azureus2.plugins.messaging.MessageException;
import org.gudy.azureus2.plugins.messaging.generic.*;
import org.gudy.azureus2.plugins.network.RateLimiter;
import org.gudy.azureus2.plugins.utils.PooledByteBuffer;
import org.gudy.azureus2.pluginsimpl.local.utils.PooledByteBufferImpl;

// Referenced classes of package org.gudy.azureus2.pluginsimpl.local.messaging:
//			GenericMessage, GenericMessageConnectionAdapter, GenericMessageConnectionDirect, GenericMessageConnectionIndirect, 
//			GenericMessageEndpointImpl, MessageManagerImpl

public class GenericMessageConnectionImpl
	implements GenericMessageConnection
{

	private static final boolean TRACE = false;
	private static final boolean TEST_TUNNEL = false;
	private MessageManagerImpl message_manager;
	private String msg_id;
	private String msg_desc;
	private GenericMessageEndpointImpl endpoint;
	private int stream_crypto;
	byte shared_secrets[][];
	private boolean incoming;
	private volatile GenericMessageConnectionAdapter delegate;
	private volatile boolean closing;
	private volatile boolean closed;
	private volatile boolean connecting;
	private List listeners;
	private int connect_method_count;
	private List inbound_rls;
	private List outbound_rls;

	protected GenericMessageConnectionImpl(MessageManagerImpl _message_manager, GenericMessageConnectionAdapter _delegate)
	{
		listeners = new ArrayList();
		message_manager = _message_manager;
		delegate = _delegate;
		incoming = true;
		connect_method_count = 1;
		delegate.setOwner(this);
	}

	protected GenericMessageConnectionImpl(MessageManagerImpl _message_manager, String _msg_id, String _msg_desc, GenericMessageEndpointImpl _endpoint, int _stream_crypto, byte _shared_secrets[][])
	{
		listeners = new ArrayList();
		message_manager = _message_manager;
		msg_id = _msg_id;
		msg_desc = _msg_desc;
		endpoint = _endpoint;
		stream_crypto = _stream_crypto;
		shared_secrets = _shared_secrets;
		connect_method_count = endpoint.getConnectionEndpoint().getProtocols().length;
		incoming = false;
	}

	public GenericMessageEndpoint getEndpoint()
	{
		return ((GenericMessageEndpoint) (endpoint != null ? endpoint : delegate.getEndpoint()));
	}

	public int getMaximumMessageSize()
	{
		return delegate != null ? delegate.getMaximumMessageSize() : 32768;
	}

	public String getType()
	{
		if (delegate == null)
			return "";
		else
			return delegate.getType();
	}

	public int getTransportType()
	{
		if (delegate == null)
			return 0;
		else
			return delegate.getTransportType();
	}

	public void addInboundRateLimiter(RateLimiter limiter)
	{
		synchronized (this)
		{
			if (delegate != null)
			{
				delegate.addInboundRateLimiter(limiter);
			} else
			{
				if (inbound_rls == null)
					inbound_rls = new ArrayList();
				inbound_rls.add(limiter);
			}
		}
	}

	public void removeInboundRateLimiter(RateLimiter limiter)
	{
		synchronized (this)
		{
			if (delegate != null)
				delegate.removeInboundRateLimiter(limiter);
			else
			if (inbound_rls != null)
				inbound_rls.remove(limiter);
		}
	}

	public void addOutboundRateLimiter(RateLimiter limiter)
	{
		synchronized (this)
		{
			if (delegate != null)
			{
				delegate.addOutboundRateLimiter(limiter);
			} else
			{
				if (outbound_rls == null)
					outbound_rls = new ArrayList();
				outbound_rls.add(limiter);
			}
		}
	}

	public void removeOutboundRateLimiter(RateLimiter limiter)
	{
		synchronized (this)
		{
			if (delegate != null)
				delegate.removeOutboundRateLimiter(limiter);
			else
			if (outbound_rls != null)
				outbound_rls.remove(limiter);
		}
	}

	public boolean isIncoming()
	{
		return incoming;
	}

	public int getConnectMethodCount()
	{
		return connect_method_count;
	}

	public void connect()
		throws MessageException
	{
		connect(null);
	}

	protected void setDelegate(GenericMessageConnectionAdapter _delegate)
	{
		synchronized (this)
		{
			delegate = _delegate;
			if (inbound_rls != null)
			{
				for (int i = 0; i < inbound_rls.size(); i++)
					delegate.addInboundRateLimiter((RateLimiter)inbound_rls.get(i));

				inbound_rls = null;
			}
			if (outbound_rls != null)
			{
				for (int i = 0; i < outbound_rls.size(); i++)
					delegate.addOutboundRateLimiter((RateLimiter)outbound_rls.get(i));

				inbound_rls = null;
			}
		}
	}

	public void connect(ByteBuffer initial_data)
		throws MessageException
	{
		if (incoming)
			throw new MessageException("Already connected");
		if (connecting)
			throw new MessageException("Connect already performed");
		connecting = true;
		if (closed)
			throw new MessageException("Connection has been closed");
		InetSocketAddress tcp_ep = endpoint.getTCP();
		if (tcp_ep != null)
		{
			connectTCP(initial_data, tcp_ep);
		} else
		{
			InetSocketAddress udp_ep = endpoint.getUDP();
			if (udp_ep != null)
				connectUDP(initial_data, udp_ep, false);
			else
				throw new MessageException("No protocols availabld");
		}
	}

	protected void connectTCP(final ByteBuffer initial_data, InetSocketAddress tcp_ep)
	{
		GenericMessageEndpointImpl gen_tcp = new GenericMessageEndpointImpl(endpoint.getNotionalAddress());
		gen_tcp.addTCP(tcp_ep);
		final GenericMessageConnectionDirect tcp_delegate = new GenericMessageConnectionDirect(msg_id, msg_desc, gen_tcp, stream_crypto, shared_secrets);
		tcp_delegate.setOwner(this);
		tcp_delegate.connect(initial_data, new GenericMessageConnectionAdapter.ConnectionListener() {

			private boolean connected;
			final GenericMessageConnectionDirect val$tcp_delegate;
			final ByteBuffer val$initial_data;
			final GenericMessageConnectionImpl this$0;

			public void connectSuccess()
			{
				connected = true;
				setDelegate(tcp_delegate);
				if (closed)
				{
					try
					{
						delegate.close();
					}
					catch (Throwable e) { }
					reportFailed(new MessageException("Connection has been closed"));
				} else
				{
					reportConnected();
				}
			}

			public void connectFailure(Throwable failure_msg)
			{
				InetSocketAddress udp_ep = endpoint.getUDP();
				if (udp_ep != null && !connected)
				{
					initial_data.rewind();
					connectUDP(initial_data, udp_ep, false);
				} else
				{
					reportFailed(failure_msg);
				}
			}

			
			{
				this$0 = GenericMessageConnectionImpl.this;
				tcp_delegate = genericmessageconnectiondirect;
				initial_data = bytebuffer;
				super();
			}
		});
	}

	protected void connectUDP(final ByteBuffer initial_data, final InetSocketAddress udp_ep, boolean nat_traversal)
	{
		final GenericMessageEndpointImpl gen_udp = new GenericMessageEndpointImpl(endpoint.getNotionalAddress());
		gen_udp.addUDP(udp_ep);
		final GenericMessageConnectionAdapter udp_delegate = new GenericMessageConnectionDirect(msg_id, msg_desc, gen_udp, stream_crypto, shared_secrets);
		udp_delegate.setOwner(this);
		if (nat_traversal)
		{
			NATTraverser nat_traverser = message_manager.getNATTraverser();
			Map request = new HashMap();
			nat_traverser.attemptTraversal(message_manager, udp_ep, request, false, new NATTraversalObserver() {

				final ByteBuffer val$initial_data;
				final GenericMessageEndpointImpl val$gen_udp;
				final GenericMessageConnectionAdapter val$udp_delegate;
				final GenericMessageConnectionImpl this$0;

				public void succeeded(final InetSocketAddress rendezvous, final InetSocketAddress target, Map reply)
				{
					if (closed)
					{
						reportFailed(new MessageException("Connection has been closed"));
					} else
					{
						connect_method_count++;
						udp_delegate.connect(initial_data, new GenericMessageConnectionAdapter.ConnectionListener() {

							private boolean connected;
							final InetSocketAddress val$rendezvous;
							final InetSocketAddress val$target;
							final 2 this$1;

							public void connectSuccess()
							{
								connected = true;
								setDelegate(udp_delegate);
								if (closed)
								{
									try
									{
										delegate.close();
									}
									catch (Throwable e) { }
									reportFailed(new MessageException("Connection has been closed"));
								} else
								{
									reportConnected();
								}
							}

							public void connectFailure(Throwable failure_msg)
							{
								if (connected)
								{
									reportFailed(failure_msg);
								} else
								{
									initial_data.rewind();
									connectTunnel(initial_data, gen_udp, rendezvous, target);
								}
							}

					
					{
						this$1 = 2.this;
						rendezvous = inetsocketaddress;
						target = inetsocketaddress1;
						super();
					}
						});
					}
				}

				public void failed(int failure_type)
				{
					reportFailed(new MessageException((new StringBuilder()).append("UDP connection attempt failed - NAT traversal failed (").append(NATTraversalObserver.FT_STRINGS[failure_type]).append(")").toString()));
				}

				public void failed(Throwable cause)
				{
					reportFailed(cause);
				}

				public void disabled()
				{
					reportFailed(new MessageException("UDP connection attempt failed as DDB is disabled"));
				}

			
			{
				this$0 = GenericMessageConnectionImpl.this;
				initial_data = bytebuffer;
				gen_udp = genericmessageendpointimpl;
				udp_delegate = genericmessageconnectionadapter;
				super();
			}
			});
		} else
		{
			udp_delegate.connect(initial_data, new GenericMessageConnectionAdapter.ConnectionListener() {

				private boolean connected;
				final GenericMessageConnectionAdapter val$udp_delegate;
				final ByteBuffer val$initial_data;
				final InetSocketAddress val$udp_ep;
				final GenericMessageConnectionImpl this$0;

				public void connectSuccess()
				{
					connected = true;
					setDelegate(udp_delegate);
					if (closed)
					{
						try
						{
							delegate.close();
						}
						catch (Throwable e) { }
						reportFailed(new MessageException("Connection has been closed"));
					} else
					{
						reportConnected();
					}
				}

				public void connectFailure(Throwable failure_msg)
				{
					if (connected)
					{
						reportFailed(failure_msg);
					} else
					{
						initial_data.rewind();
						connectUDP(initial_data, udp_ep, true);
					}
				}

			
			{
				this$0 = GenericMessageConnectionImpl.this;
				udp_delegate = genericmessageconnectionadapter;
				initial_data = bytebuffer;
				udp_ep = inetsocketaddress;
				super();
			}
			});
		}
	}

	protected void connectTunnel(ByteBuffer initial_data, GenericMessageEndpoint ep, InetSocketAddress rendezvous, InetSocketAddress target)
	{
		final GenericMessageConnectionIndirect tunnel_delegate = new GenericMessageConnectionIndirect(message_manager, msg_id, msg_desc, ep, rendezvous, target);
		tunnel_delegate.setOwner(this);
		tunnel_delegate.connect(initial_data, new GenericMessageConnectionAdapter.ConnectionListener() {

			final GenericMessageConnectionIndirect val$tunnel_delegate;
			final GenericMessageConnectionImpl this$0;

			public void connectSuccess()
			{
				setDelegate(tunnel_delegate);
				if (closed)
				{
					try
					{
						delegate.close();
					}
					catch (Throwable e) { }
					reportFailed(new MessageException("Connection has been closed"));
				} else
				{
					reportConnected();
				}
			}

			public void connectFailure(Throwable failure_msg)
			{
				reportFailed(failure_msg);
			}

			
			{
				this$0 = GenericMessageConnectionImpl.this;
				tunnel_delegate = genericmessageconnectionindirect;
				super();
			}
		});
	}

	protected void accepted()
	{
		delegate.accepted();
	}

	public void send(PooledByteBuffer message)
		throws MessageException
	{
		int size = ((PooledByteBufferImpl)message).getBuffer().remaining((byte)1);
		if (size > getMaximumMessageSize())
		{
			throw new MessageException((new StringBuilder()).append("Message is too large: supplied is ").append(size).append(", maximum is ").append(getMaximumMessageSize()).toString());
		} else
		{
			delegate.send(message);
			return;
		}
	}

	protected void receive(GenericMessage message)
	{
		boolean handled = false;
		for (int i = 0; i < listeners.size();)
		{
			PooledByteBuffer buffer = new PooledByteBufferImpl(message.getPayload());
			try
			{
				((GenericMessageConnectionListener)listeners.get(i)).receive(this, buffer);
				handled = true;
				continue;
			}
			catch (Throwable f)
			{
				buffer.returnToPool();
				if (!(f instanceof MessageException))
					Debug.printStackTrace(f);
				i++;
			}
		}

		if (!handled && !closed && !closing)
			Debug.out("GenericMessage: incoming message not handled");
	}

	public void closing()
	{
		closing = true;
	}

	public void close()
		throws MessageException
	{
		closed = true;
		if (delegate != null)
			delegate.close();
	}

	protected void reportConnected()
	{
		for (int i = 0; i < listeners.size(); i++)
			try
			{
				((GenericMessageConnectionListener)listeners.get(i)).connected(this);
			}
			catch (Throwable f)
			{
				Debug.printStackTrace(f);
			}

	}

	protected void reportFailed(Throwable e)
	{
		for (int i = 0; i < listeners.size(); i++)
			try
			{
				((GenericMessageConnectionListener)listeners.get(i)).failed(this, e);
			}
			catch (Throwable f)
			{
				Debug.printStackTrace(f);
			}

	}

	public void addListener(GenericMessageConnectionListener listener)
	{
		listeners.add(listener);
	}

	public void removeListener(GenericMessageConnectionListener listener)
	{
		listeners.remove(listener);
	}





}