pepeertransportprotocol.java

java 文件下载器。可自定义

	public boolean isIncoming()
	{
		return incoming;
	}

	public boolean isOptimisticUnchoke()
	{
		return is_optimistic_unchoke && !isChokedByMe();
	}

	public void setOptimisticUnchoke(boolean is_optimistic)
	{
		is_optimistic_unchoke = is_optimistic;
	}

	public PEPeerControl getControl()
	{
		return manager;
	}

	public PEPeerManager getManager()
	{
		return manager;
	}

	public PEPeerStats getStats()
	{
		return peer_stats;
	}

	public int[] getPriorityOffsets()
	{
		return null;
	}

	public boolean requestAllocationStarts(int base_priorities[])
	{
		return false;
	}

	public void requestAllocationComplete()
	{
	}

	public BitFlags getAvailable()
	{
		return peerHavePieces;
	}

	public boolean isPieceAvailable(int pieceNumber)
	{
		if (peerHavePieces != null)
			return peerHavePieces.flags[pieceNumber];
		else
			return false;
	}

	public boolean isChokingMe()
	{
		return choked_by_other_peer;
	}

	public boolean isChokedByMe()
	{
		return choking_other_peer;
	}

	public boolean isInteresting()
	{
		return interested_in_other_peer;
	}

	public boolean isInterested()
	{
		return other_peer_interested_in_me;
	}

	public boolean isSeed()
	{
		return seeding;
	}

	public boolean isRelativeSeed()
	{
		return (relativeSeeding & 2) != 0;
	}

	private void setSeed(boolean s)
	{
		if (seeding != s)
		{
			seeding = s;
			if (peer_exchange_item != null && s)
				peer_exchange_item.seedStatusChanged();
		}
	}

	public boolean isSnubbed()
	{
		return snubbed != 0L;
	}

	public long getSnubbedTime()
	{
		if (snubbed == 0L)
			return 0L;
		long now = SystemTime.getCurrentTime();
		if (now < snubbed)
			snubbed = now - 26L;
		return now - snubbed;
	}

	public void setSnubbed(boolean b)
	{
		if (!closing)
		{
			long now = SystemTime.getCurrentTime();
			if (!b)
			{
				if (snubbed != 0L)
				{
					snubbed = 0L;
					manager.decNbPeersSnubbed();
					if (!choked_by_other_peer)
						unchokedTime = now;
				}
			} else
			if (snubbed == 0L)
			{
				snubbed = now;
				manager.incNbPeersSnubbed();
				if (!choked_by_other_peer)
				{
					long unchoked = now - unchokedTime;
					if (unchoked > 0L)
						unchokedTimeTotal += unchoked;
				}
			}
		}
	}

	public void setUploadHint(int spreadTime)
	{
		spreadTimeHint = spreadTime;
	}

	public int getUploadHint()
	{
		return spreadTimeHint;
	}

	public void setUniqueAnnounce(int _uniquePiece)
	{
		uniquePiece = _uniquePiece;
	}

	public int getUniqueAnnounce()
	{
		return uniquePiece;
	}

	public Object getData(String key)
	{
		return getUserData(key);
	}

	public void setData(String key, Object value)
	{
		setUserData(key, value);
	}

	public Object getUserData(Object key)
	{
		Object obj;
		general_mon.enter();
		if (data != null)
			break MISSING_BLOCK_LABEL_25;
		obj = null;
		general_mon.exit();
		return obj;
		obj = data.get(key);
		general_mon.exit();
		return obj;
		Exception exception;
		exception;
		general_mon.exit();
		throw exception;
	}

	public void setUserData(Object key, Object value)
	{
		general_mon.enter();
		if (data == null)
			data = new LightHashMap();
		if (value == null)
		{
			if (data.containsKey(key))
			{
				data.remove(key);
				if (data.size() == 0)
					data = null;
			}
		} else
		{
			data.put(key, value);
		}
		general_mon.exit();
		break MISSING_BLOCK_LABEL_105;
		Exception exception;
		exception;
		general_mon.exit();
		throw exception;
	}

	public String getIPHostName()
	{
		if (ip_resolved == null)
		{
			ip_resolved = ip;
			ip_resolver_request = IPToHostNameResolver.addResolverRequest(ip_resolved, new IPToHostNameResolverListener() {

				final PEPeerTransportProtocol this$0;

				public final void IPResolutionComplete(String res, boolean ok)
				{
					ip_resolved = res;
				}

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

	private void cancelRequests()
	{
		if (!closing)
		{
			Message type[] = {
				new BTRequest(-1, -1, -1, other_peer_request_version)
			};
			connection.getOutgoingMessageQueue().removeMessagesOfType(type, false);
		}
		if (requested == null || requested.size() <= 0)
			break MISSING_BLOCK_LABEL_164;
		requested_mon.enter();
		if (!closing)
		{
			long timeSinceGoodData = getTimeSinceGoodDataReceived();
			if (timeSinceGoodData == -1L || timeSinceGoodData > 60000L)
				setSnubbed(true);
		}
		for (int i = requested.size() - 1; i >= 0; i--)
		{
			DiskManagerReadRequest request = (DiskManagerReadRequest)requested.remove(i);
			manager.requestCanceled(request);
		}

		requested_mon.exit();
		break MISSING_BLOCK_LABEL_164;
		Exception exception;
		exception;
		requested_mon.exit();
		throw exception;
	}

	public int getMaxNbRequests()
	{
		return -1;
	}

	public int getNbRequests()
	{
		return requested.size();
	}

	public List getExpiredRequests()
	{
		List result = null;
		for (int i = requested.size() - 1; i >= 0; i--)
		{
			DiskManagerReadRequest request = (DiskManagerReadRequest)requested.get(i);
			if (!request.isExpired())
				continue;
			if (result == null)
				result = new ArrayList();
			result.add(request);
		}

		return result;
		Throwable e;
		e;
		return result;
	}

	private boolean hasBeenRequested(DiskManagerReadRequest request)
	{
		boolean flag;
		requested_mon.enter();
		flag = requested.contains(request);
		requested_mon.exit();
		return flag;
		Exception exception;
		exception;
		requested_mon.exit();
		throw exception;
	}

	/**
	 * @deprecated Method addRequest is deprecated
	 */

	protected void addRequest(DiskManagerReadRequest request)
	{
		requested_mon.enter();
		requested.add(request);
		requested_mon.exit();
		break MISSING_BLOCK_LABEL_36;
		Exception exception;
		exception;
		requested_mon.exit();
		throw exception;
		_lastPiece = request.getPieceNumber();
		return;
	}

	protected void removeRequest(DiskManagerReadRequest request)
	{
		requested_mon.enter();
		requested.remove(request);
		requested_mon.exit();
		break MISSING_BLOCK_LABEL_36;
		Exception exception;
		exception;
		requested_mon.exit();
		throw exception;
		BTRequest msg = new BTRequest(request.getPieceNumber(), request.getOffset(), request.getLength(), other_peer_request_version);
		connection.getOutgoingMessageQueue().removeMessage(msg, false);
		msg.destroy();
		return;
	}

	private void resetRequestsTime(long now)
	{
		requested_mon.enter();
		int requestedSize = requested.size();
		for (int i = 0; i < requestedSize; i++)
		{
			DiskManagerReadRequest request = (DiskManagerReadRequest)requested.get(i);
			if (request != null)
				request.resetTime(now);
		}

		requested_mon.exit();
		break MISSING_BLOCK_LABEL_79;
		Exception exception;
		exception;
		requested_mon.exit();
		throw exception;
	}

	public String toString()
	{
		if (connection != null && connection.isConnected())
			return (new StringBuilder()).append(connection).append(isTCP() ? " [" : "(UDP) [").append(client).append("]").toString();
		else
			return (new StringBuilder()).append(isIncoming() ? "R: " : "L: ").append(ip).append(":").append(port).append(isTCP() ? " [" : "(UDP) [").append(client).append("]").toString();
	}

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

	public void doKeepAliveCheck()
	{
		long now = SystemTime.getCurrentTime();
		long wait_time = now - last_message_sent_time;
		if (last_message_sent_time == 0L || wait_time < 0L)
		{
			last_message_sent_time = now;
			return;
		}
		if (wait_time > 0x1d4c0L)
		{
			sendKeepAlive();
			last_message_sent_time = now;
		}
	}

	public boolean doTimeoutChecks()
	{
		long now = SystemTime.getCurrentTime();
		if (connection_state == 4)
		{
			if (last_message_received_time > now)
				last_message_received_time = now;
			if (last_data_message_received_time > now)
				last_data_message_received_time = now;
			if (now - last_message_received_time > 0x493e0L && now - last_data_message_received_time > 0x493e0L)
			{
				closeConnectionInternally("timed out while waiting for messages", false, true);
				return true;
			}
		} else
		if (connection_state == 2)
			if (connection_established_time > now)
				connection_established_time = now;
			else
			if (now - connection_established_time > 0x2bf20L)
			{
				closeConnectionInternally("timed out while waiting for handshake");
				return true;
			}
		return false;
	}

	public void doPerformanceTuningCheck()
	{
		Transport transport = connection.getTransport();
		if (transport != null && peer_stats != null && outgoing_piece_message_handler != null)
		{
			long send_rate = peer_stats.getDataSendRate() + peer_stats.getProtocolSendRate();
			if (send_rate >= 0x2faf08L)