messagemanagerimpl.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:   MessageManagerImpl.java

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

import com.aelitis.azureus.core.AzureusCore;
import com.aelitis.azureus.core.nat.NATTraversalHandler;
import com.aelitis.azureus.core.nat.NATTraverser;
import com.aelitis.azureus.core.networkmanager.NetworkConnection;
import com.aelitis.azureus.core.networkmanager.NetworkManager;
import com.aelitis.azureus.core.networkmanager.Transport;
import com.aelitis.azureus.core.networkmanager.impl.TransportHelper;
import com.aelitis.azureus.core.peermanager.messaging.MessageException;
import com.aelitis.azureus.core.peermanager.messaging.MessageManager;
import com.aelitis.azureus.core.peermanager.messaging.MessageStreamDecoder;
import com.aelitis.azureus.core.peermanager.messaging.MessageStreamEncoder;
import com.aelitis.azureus.core.peermanager.messaging.MessageStreamFactory;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import org.gudy.azureus2.core3.util.Debug;
import org.gudy.azureus2.core3.util.SHA1Simple;
import org.gudy.azureus2.plugins.PluginInterface;
import org.gudy.azureus2.plugins.download.Download;
import org.gudy.azureus2.plugins.download.DownloadManager;
import org.gudy.azureus2.plugins.download.DownloadManagerListener;
import org.gudy.azureus2.plugins.download.DownloadPeerListener;
import org.gudy.azureus2.plugins.messaging.Message;
import org.gudy.azureus2.plugins.messaging.MessageManagerListener;
import org.gudy.azureus2.plugins.messaging.generic.GenericMessageConnection;
import org.gudy.azureus2.plugins.messaging.generic.GenericMessageEndpoint;
import org.gudy.azureus2.plugins.messaging.generic.GenericMessageHandler;
import org.gudy.azureus2.plugins.messaging.generic.GenericMessageRegistration;
import org.gudy.azureus2.plugins.peers.Peer;
import org.gudy.azureus2.plugins.peers.PeerListener;
import org.gudy.azureus2.plugins.peers.PeerManager;
import org.gudy.azureus2.plugins.peers.PeerManagerListener;

// Referenced classes of package org.gudy.azureus2.pluginsimpl.local.messaging:
//			GenericMessageConnectionIndirect, MessageAdapter, GenericMessageConnectionDirect, GenericMessageConnectionImpl, 
//			GenericMessageEndpointImpl, GenericMessageDecoder, GenericMessageEncoder

public class MessageManagerImpl
	implements org.gudy.azureus2.plugins.messaging.MessageManager, NATTraversalHandler
{

	private static MessageManagerImpl instance;
	private final HashMap compat_checks = new HashMap();
	private final DownloadManagerListener download_manager_listener = new DownloadManagerListener() {

		final MessageManagerImpl this$0;

		public void downloadAdded(Download dwnld)
		{
			dwnld.addPeerListener(new DownloadPeerListener() {

				final 1 this$1;

				public void peerManagerAdded(final Download download, PeerManager peer_manager)
				{
					peer_manager.addListener(new PeerManagerListener() {

						final Download val$download;
						final 1 this$2;

						public void peerAdded(PeerManager manager, final Peer peer)
						{
							peer.addListener(new PeerListener() {

								final Peer val$peer;
								final 1 this$3;

								public void stateChanged(int new_state)
								{
									if (new_state == 30 && peer.supportsMessaging())
									{
										Message messages[] = peer.getSupportedMessages();
label0:
										for (int i = 0; i < messages.length; i++)
										{
											Message msg = messages[i];
											Iterator it = compat_checks.entrySet().iterator();
											do
											{
												if (!it.hasNext())
													continue label0;
												java.util.Map.Entry entry = (java.util.Map.Entry)it.next();
												Message message = (Message)entry.getKey();
												if (msg.getID().equals(message.getID()))
												{
													MessageManagerListener listener = (MessageManagerListener)entry.getValue();
													listener.compatiblePeerFound(download, peer, message);
												}
											} while (true);
										}

									}
								}

								public void sentBadChunk(int i, int j)
								{
								}

							
							{
								this$3 = 1.this;
								peer = peer1;
								super();
							}
							});
						}

						public void peerRemoved(PeerManager manager, Peer peer)
						{
							MessageManagerListener listener;
							for (Iterator i = compat_checks.values().iterator(); i.hasNext(); listener.peerRemoved(download, peer))
								listener = (MessageManagerListener)i.next();

						}

						
						{
							this$2 = 1.this;
							download = download1;
							super();
						}
					});
				}

				public void peerManagerRemoved(Download download1, PeerManager peermanager)
				{
				}

					
					{
						this$1 = 1.this;
						super();
					}
			});
		}

		public void downloadRemoved(Download download1)
		{
		}

			
			{
				this$0 = MessageManagerImpl.this;
				super();
			}
	};
	private AzureusCore core;
	private Map message_handlers;

	public static synchronized MessageManagerImpl getSingleton(AzureusCore core)
	{
		if (instance == null)
			instance = new MessageManagerImpl(core);
		return instance;
	}

	private MessageManagerImpl(AzureusCore _core)
	{
		message_handlers = new HashMap();
		core = _core;
		core.getNATTraverser().registerHandler(this);
	}

	public NATTraverser getNATTraverser()
	{
		return core.getNATTraverser();
	}

	public void registerMessageType(Message message)
		throws org.gudy.azureus2.plugins.messaging.MessageException
	{
		try
		{
			MessageManager.getSingleton().registerMessageType(new MessageAdapter(message));
		}
		catch (MessageException me)
		{
			throw new org.gudy.azureus2.plugins.messaging.MessageException(me.getMessage());
		}
	}

	public void deregisterMessageType(Message message)
	{
		MessageManager.getSingleton().deregisterMessageType(new MessageAdapter(message));
	}

	public void locateCompatiblePeers(PluginInterface plug_interface, Message message, MessageManagerListener listener)
	{
		compat_checks.put(message, listener);
		if (compat_checks.size() == 1)
			plug_interface.getDownloadManager().addListener(download_manager_listener);
	}

	public void cancelCompatiblePeersLocation(MessageManagerListener orig_listener)
	{
		Iterator it = compat_checks.values().iterator();
		do
		{
			if (!it.hasNext())
				break;
			MessageManagerListener listener = (MessageManagerListener)it.next();
			if (listener != orig_listener)
				continue;
			it.remove();
			break;
		} while (true);
	}

	public GenericMessageRegistration registerGenericMessageType(String _type, final String description, final int stream_crypto, final GenericMessageHandler handler)
		throws org.gudy.azureus2.plugins.messaging.MessageException
	{
		final String type = (new StringBuilder()).append("AEGEN:").append(_type).toString();
		final byte type_bytes[] = type.getBytes();
		final byte shared_secrets[][] = {
			(new SHA1Simple()).calculateHash(type_bytes)
		};
		synchronized (message_handlers)
		{
			message_handlers.put(type, handler);
		}
		final com.aelitis.azureus.core.networkmanager.NetworkManager.ByteMatcher matcher = new com.aelitis.azureus.core.networkmanager.NetworkManager.ByteMatcher() {

			final byte val$type_bytes[];
			final byte val$shared_secrets[][];
			final MessageManagerImpl this$0;

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

			public int maxSize()
			{
				return type_bytes.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(type_bytes));
				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 shared_secrets;
			}

			public int getSpecificPort()
			{
				return -1;
			}

			
			{
				this$0 = MessageManagerImpl.this;
				type_bytes = abyte0;
				shared_secrets = abyte1;
				super();
			}
		};
		NetworkManager.getSingleton().requestIncomingConnectionRouting(matcher, new com.aelitis.azureus.core.networkmanager.NetworkManager.RoutingListener() {

			final byte val$type_bytes[];
			final String val$type;
			final String val$description;
			final int val$stream_crypto;
			final byte val$shared_secrets[][];
			final GenericMessageHandler val$handler;
			final MessageManagerImpl this$0;

			public void connectionRouted(NetworkConnection connection, Object routing_data)
			{
				try
				{
					ByteBuffer skip_buffer[] = {
						ByteBuffer.allocate(type_bytes.length)
					};
					connection.getTransport().read(skip_buffer, 0, 1);
					if (skip_buffer[0].remaining() != 0)
						Debug.out("incomplete read");
					GenericMessageEndpointImpl endpoint = new GenericMessageEndpointImpl(connection.getEndpoint());
					GenericMessageConnectionDirect direct_connection = GenericMessageConnectionDirect.receive(endpoint, type, description, stream_crypto, shared_secrets);
					GenericMessageConnectionImpl new_connection = new GenericMessageConnectionImpl(MessageManagerImpl.this, direct_connection);
					direct_connection.connect(connection);
					if (handler.accept(new_connection))
						new_connection.accepted();
					else
						connection.close();
				}
				catch (Throwable e)
				{
					Debug.printStackTrace(e);
					connection.close();
				}
			}

			public boolean autoCryptoFallback()
			{
				return stream_crypto != 3;
			}

			
			{
				this$0 = MessageManagerImpl.this;
				type_bytes = abyte0;
				type = s;
				description = s1;
				stream_crypto = i;
				shared_secrets = abyte1;
				handler = genericmessagehandler;
				super();
			}
		}, new MessageStreamFactory() {

			final String val$type;
			final String val$description;
			final MessageManagerImpl this$0;

			public MessageStreamEncoder createEncoder()
			{
				return new GenericMessageEncoder();
			}

			public MessageStreamDecoder createDecoder()
			{
				return new GenericMessageDecoder(type, description);
			}

			
			{
				this$0 = MessageManagerImpl.this;
				type = s;
				description = s1;
				super();
			}
		});
		return new GenericMessageRegistration() {

			final String val$type;
			final String val$description;
			final int val$stream_crypto;
			final byte val$shared_secrets[][];
			final com.aelitis.azureus.core.networkmanager.NetworkManager.ByteMatcher val$matcher;
			final MessageManagerImpl this$0;

			public GenericMessageEndpoint createEndpoint(InetSocketAddress notional_target)
			{
				return new GenericMessageEndpointImpl(notional_target);
			}

			public GenericMessageConnection createConnection(GenericMessageEndpoint endpoint)
				throws org.gudy.azureus2.plugins.messaging.MessageException
			{
				return new GenericMessageConnectionImpl(MessageManagerImpl.this, type, description, (GenericMessageEndpointImpl)endpoint, stream_crypto, shared_secrets);
			}

			public void cancel()
			{
				NetworkManager.getSingleton().cancelIncomingConnectionRouting(matcher);
				synchronized (message_handlers)
				{
					message_handlers.remove(type);
				}
			}

			
			{
				this$0 = MessageManagerImpl.this;
				type = s;
				description = s1;
				stream_crypto = i;
				shared_secrets = abyte0;
				matcher = bytematcher;
				super();
			}
		};
	}

	protected GenericMessageHandler getHandler(String type)
	{
		Map map = message_handlers;
		JVM INSTR monitorenter ;
		return (GenericMessageHandler)message_handlers.get(type);
		Exception exception;
		exception;
		throw exception;
	}

	public int getType()
	{
		return 2;
	}

	public String getName()
	{
		return "Generic Messaging";
	}

	public Map process(InetSocketAddress originator, Map message)
	{
		return GenericMessageConnectionIndirect.receive(this, originator, message);
	}


}