pepeertransportprotocol.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:   PEPeerTransportProtocol.java

package org.gudy.azureus2.core3.peer.impl.transport;

import com.aelitis.azureus.core.AzureusCore;
import com.aelitis.azureus.core.impl.AzureusCoreImpl;
import com.aelitis.azureus.core.networkmanager.*;
import com.aelitis.azureus.core.networkmanager.impl.tcp.ProtocolEndpointTCP;
import com.aelitis.azureus.core.networkmanager.impl.tcp.TCPNetworkManager;
import com.aelitis.azureus.core.networkmanager.impl.udp.ProtocolEndpointUDP;
import com.aelitis.azureus.core.networkmanager.impl.udp.UDPNetworkManager;
import com.aelitis.azureus.core.peermanager.messaging.*;
import com.aelitis.azureus.core.peermanager.messaging.azureus.*;
import com.aelitis.azureus.core.peermanager.messaging.bittorrent.*;
import com.aelitis.azureus.core.peermanager.messaging.bittorrent.ltep.*;
import com.aelitis.azureus.core.peermanager.peerdb.*;
import com.aelitis.azureus.core.peermanager.piecepicker.PiecePicker;
import com.aelitis.azureus.core.peermanager.piecepicker.util.BitFlags;
import com.aelitis.azureus.core.peermanager.utils.*;
import java.io.PrintStream;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.util.*;
import org.gudy.azureus2.core3.config.COConfigurationManager;
import org.gudy.azureus2.core3.config.ParameterListener;
import org.gudy.azureus2.core3.disk.*;
import org.gudy.azureus2.core3.global.GlobalManager;
import org.gudy.azureus2.core3.logging.*;
import org.gudy.azureus2.core3.peer.*;
import org.gudy.azureus2.core3.peer.impl.*;
import org.gudy.azureus2.core3.peer.util.PeerIdentityManager;
import org.gudy.azureus2.core3.peer.util.PeerUtils;
import org.gudy.azureus2.core3.util.*;
import org.gudy.azureus2.plugins.dht.mainline.MainlineDHTProvider;
import org.gudy.azureus2.plugins.network.Connection;
import org.gudy.azureus2.plugins.peers.Peer;
import org.gudy.azureus2.pluginsimpl.local.network.ConnectionImpl;

public class PEPeerTransportProtocol extends LogRelation
	implements PEPeerTransport
{
	private static final class DisconnectedTransportQueue extends LinkedHashMap
	{
		private static final class QueueEntry
		{

			final PEPeerTransportProtocol transport;
			final long addTime = SystemTime.getMonotonousTime();

			public QueueEntry(PEPeerTransportProtocol trans)
			{
				transport = trans;
			}
		}


		private static final long MAX_CACHE_AGE = 0x1d4c0L;

		private void performCleaning()
		{
			if (size() > 20)
			{
				Iterator it = values().iterator();
				long now = SystemTime.getMonotonousTime();
				do
				{
					if (!it.hasNext() || size() <= 20)
						break;
					QueueEntry eldest = (QueueEntry)it.next();
					if (now - eldest.addTime <= 0x1d4c0L)
						break;
					it.remove();
				} while (true);
			}
		}

		protected boolean removeEldestEntry(java.util.Map.Entry eldest)
		{
			return size() > 100;
		}

		public synchronized Object put(HashWrapper key, PEPeerTransportProtocol value)
		{
			performCleaning();
			return super.put(key, new QueueEntry(value));
		}

		public synchronized PEPeerTransportProtocol remove(HashWrapper key)
		{
			performCleaning();
			QueueEntry entry = (QueueEntry)super.remove(key);
			if (entry != null)
				return entry.transport;
			else
				return null;
		}

		public DisconnectedTransportQueue()
		{
			super(20, 0.75F);
		}
	}

	protected static class MutableInteger
	{

		private int value;

		protected void setValue(int v)
		{
			value = v;
		}

		protected int getValue()
		{
			return value;
		}

		public int hashCode()
		{
			return value;
		}

		public boolean equals(Object obj)
		{
			if (obj instanceof MutableInteger)
				return value == ((MutableInteger)obj).value;
			else
				return false;
		}

		protected MutableInteger(int v)
		{
			value = v;
		}
	}


	protected static final LogIDs LOGID;
	private volatile int _lastPiece;
	protected final PEPeerControl manager;
	protected final DiskManager diskManager;
	protected final PiecePicker piecePicker;
	protected final int nbPieces;
	private final String peer_source;
	private byte peer_id[];
	private final String ip;
	protected String ip_resolved;
	private IPToHostNameResolverRequest ip_resolver_request;
	private int port;
	private PeerItem peer_item_identity;
	private int tcp_listen_port;
	private int udp_listen_port;
	private int udp_non_data_port;
	private byte crypto_level;
	protected PEPeerStats peer_stats;
	private final ArrayList requested;
	private final AEMonitor requested_mon;
	private Map data;
	private long lastNeededUndonePieceChange;
	protected boolean choked_by_other_peer;
	protected long unchokedTimeTotal;
	protected long unchokedTime;
	protected boolean choking_other_peer;
	private boolean interested_in_other_peer;
	private boolean other_peer_interested_in_me;
	private long snubbed;
	private volatile BitFlags peerHavePieces;
	private volatile boolean availabilityAdded;
	private volatile boolean received_bitfield;
	private boolean handshake_sent;
	private boolean seeding;
	private static final byte RELATIVE_SEEDING_NONE = 0;
	private static final byte RELATIVE_SEEDING_UPLOAD_ONLY_INDICATED = 1;
	private static final byte RELATIVE_SEEDING_UPLOAD_ONLY_SEED = 2;
	private byte relativeSeeding;
	private final boolean incoming;
	protected volatile boolean closing;
	private volatile int current_peer_state;
	protected NetworkConnection connection;
	private OutgoingBTPieceMessageHandler outgoing_piece_message_handler;
	private OutgoingBTHaveMessageAggregator outgoing_have_message_aggregator;
	private Connection plugin_connection;
	private boolean identityAdded;
	protected int connection_state;
	private String client;
	private String client_peer_id;
	private String client_handshake;
	private String client_handshake_version;
	private int uniquePiece;
	private int reservedPiece;
	private int spreadTimeHint;
	protected long last_message_sent_time;
	protected long last_message_received_time;
	protected long last_data_message_received_time;
	protected long last_good_data_time;
	protected long last_data_message_sent_time;
	private long connection_established_time;
	private int consecutive_no_request_count;
	private int messaging_mode;
	private Message supported_messages[];
	private byte other_peer_bitfield_version;
	private byte other_peer_cancel_version;
	private byte other_peer_choke_version;
	private byte other_peer_handshake_version;
	private byte other_peer_bt_have_version;
	private byte other_peer_az_have_version;
	private byte other_peer_interested_version;
	private byte other_peer_keep_alive_version;
	private byte other_peer_pex_version;
	private byte other_peer_piece_version;
	private byte other_peer_unchoke_version;
	private byte other_peer_uninterested_version;
	private byte other_peer_request_version;
	private byte other_peer_bt_lt_ext_version;
	private byte other_peer_az_request_hint_version;
	private byte other_peer_az_bad_piece_version;
	private boolean ut_pex_enabled;
	private boolean ml_dht_enabled;
	private final AEMonitor closing_mon;
	private final AEMonitor general_mon;
	private byte handshake_reserved_bytes[];
	private LinkedHashMap recent_outgoing_requests;
	private AEMonitor recent_outgoing_requests_mon;
	private boolean has_received_initial_pex;
	private static final boolean SHOW_DISCARD_RATE_STATS;
	private static int requests_discarded = 0;
	private static int requests_discarded_endgame = 0;
	private static int requests_recovered = 0;
	private static int requests_completed = 0;
	private static final int REQUEST_HINT_MAX_LIFE = 0x249f0;
	private int request_hint[];
	private List peer_listeners_cow;
	private final AEMonitor peer_listeners_mon;
	protected static boolean ENABLE_LAZY_BITFIELD;
	private boolean priority_connection;
	private static final DisconnectedTransportQueue recentlyDisconnected = new DisconnectedTransportQueue();
	private static boolean fast_unchoke_new_peers;
	private static final Random rnd;
	private static final byte sessionSecret[];
	private HashWrapper peerSessionID;
	private HashWrapper mySessionID;
	private boolean allowReconnect;
	private boolean is_optimistic_unchoke;
	private PeerExchangerItem peer_exchange_item;
	private boolean peer_exchange_supported;
	protected PeerMessageLimiter message_limiter;
	private boolean request_hint_supported;
	private boolean bad_piece_supported;
	private boolean have_aggregation_disabled;
	static Map lt_ext_map = Collections.singletonMap("ut_pex", new Integer(1));

	public PEPeerTransportProtocol(PEPeerControl _manager, String _peer_source, NetworkConnection _connection, Map _initial_user_data)
	{
		_lastPiece = -1;
		tcp_listen_port = 0;
		udp_listen_port = 0;
		udp_non_data_port = 0;
		requested = new ArrayList();
		requested_mon = new AEMonitor("PEPeerTransportProtocol:Req");
		choked_by_other_peer = true;
		choking_other_peer = true;
		interested_in_other_peer = false;
		other_peer_interested_in_me = false;
		snubbed = 0L;
		peerHavePieces = null;
		availabilityAdded = false;
		seeding = false;
		relativeSeeding = 0;
		closing = false;
		identityAdded = false;
		connection_state = 0;
		client = "";
		client_peer_id = "";
		client_handshake = "";
		client_handshake_version = "";
		uniquePiece = -1;
		reservedPiece = -1;
		spreadTimeHint = 0;
		last_message_sent_time = 0L;
		last_message_received_time = 0L;
		last_data_message_received_time = -1L;
		last_good_data_time = -1L;
		last_data_message_sent_time = -1L;
		connection_established_time = 0L;
		messaging_mode = 1;
		supported_messages = null;
		other_peer_bitfield_version = 1;
		other_peer_cancel_version = 1;
		other_peer_choke_version = 1;
		other_peer_handshake_version = 1;
		other_peer_bt_have_version = 1;
		other_peer_az_have_version = 1;
		other_peer_interested_version = 1;
		other_peer_keep_alive_version = 1;
		other_peer_pex_version = 1;
		other_peer_piece_version = 1;
		other_peer_unchoke_version = 1;
		other_peer_uninterested_version = 1;
		other_peer_request_version = 1;
		other_peer_bt_lt_ext_version = 1;
		other_peer_az_request_hint_version = 1;
		other_peer_az_bad_piece_version = 1;
		ut_pex_enabled = false;
		ml_dht_enabled = false;
		closing_mon = new AEMonitor("PEPeerTransportProtocol:closing");
		general_mon = new AEMonitor("PEPeerTransportProtocol:data");
		handshake_reserved_bytes = null;
		has_received_initial_pex = false;
		peer_listeners_mon = new AEMonitor("PEPeerTransportProtocol:PL");
		is_optimistic_unchoke = false;
		peer_exchange_item = null;
		peer_exchange_supported = false;
		manager = _manager;
		peer_source = _peer_source;
		connection = _connection;
		data = _initial_user_data;
		incoming = true;
		diskManager = manager.getDiskManager();
		piecePicker = manager.getPiecePicker();
		nbPieces = diskManager.getNbPieces();
		InetSocketAddress notional_address = _connection.getEndpoint().getNotionalAddress();
		ip = notional_address.getAddress().getHostAddress();
		port = notional_address.getPort();
		peer_item_identity = PeerItemFactory.createPeerItem(ip, port, PeerItem.convertSourceID(_peer_source), (byte)0, 0, (byte)1, 0);
		plugin_connection = new ConnectionImpl(connection, incoming);
		peer_stats = manager.createPeerStats(this);
		changePeerState(10);
	}

	public void start()
	{
		if (incoming)
			connection.connect(3, new com.aelitis.azureus.core.networkmanager.NetworkConnection.ConnectionListener() {

				final PEPeerTransportProtocol this$0;

				public final void connectStarted()
				{
					connection_state = 1;
				}

				public final void connectSuccess(ByteBuffer remaining_initial_data)
				{
					if (Logger.isEnabled())
						Logger.log(new LogEvent(PEPeerTransportProtocol.this, PEPeerTransportProtocol.LOGID, "In: Established incoming connection"));
					generateSessionId();
					initializeConnection();
					sendBTHandshake();
				}

				public final void connectFailure(Throwable failure_msg)
				{
					Debug.out("ERROR: incoming connect failure: ", failure_msg);
					closeConnectionInternally((new StringBuilder()).append("ERROR: incoming connect failure [").append(PEPeerTransportProtocol.this).append("] : ").append(failure_msg.getMessage()).toString(), true, true);
				}

				public final void exceptionThrown(Throwable error)
				{
					if (error.getMessage() == null)
						Debug.out(error);
					closeConnectionInternally((new StringBuilder()).append("connection exception: ").append(error.getMessage()).toString(), false, true);
				}

				public String getDescription()
				{
					return getString();
				}

			
			{
				this$0 = PEPeerTransportProtocol.this;
				super();
			}
			});
	}

	public PEPeerTransportProtocol(PEPeerControl _manager, String _peer_source, String _ip, int _tcp_port, int _udp_port, boolean _use_tcp, boolean _require_crypto_handshake, 
			byte _crypto_level, Map _initial_user_data)
	{
		_lastPiece = -1;
		tcp_listen_port = 0;
		udp_listen_port = 0;
		udp_non_data_port = 0;
		requested = new ArrayList();
		requested_mon = new AEMonitor("PEPeerTransportProtocol:Req");
		choked_by_other_peer = true;
		choking_other_peer = true;
		interested_in_other_peer = false;
		other_peer_interested_in_me = false;
		snubbed = 0L;
		peerHavePieces = null;
		availabilityAdded = false;
		seeding = false;
		relativeSeeding = 0;
		closing = false;
		identityAdded = false;
		connection_state = 0;
		client = "";
		client_peer_id = "";
		client_handshake = "";
		client_handshake_version = "";
		uniquePiece = -1;
		reservedPiece = -1;
		spreadTimeHint = 0;
		last_message_sent_time = 0L;
		last_message_received_time = 0L;
		last_data_message_received_time = -1L;
		last_good_data_time = -1L;
		last_data_message_sent_time = -1L;
		connection_established_time = 0L;
		messaging_mode = 1;
		supported_messages = null;
		other_peer_bitfield_version = 1;
		other_peer_cancel_version = 1;
		other_peer_choke_version = 1;
		other_peer_handshake_version = 1;
		other_peer_bt_have_version = 1;
		other_peer_az_have_version = 1;
		other_peer_interested_version = 1;
		other_peer_keep_alive_version = 1;
		other_peer_pex_version = 1;
		other_peer_piece_version = 1;
		other_peer_unchoke_version = 1;