pepeertransportprotocol.java

java 文件下载器。可自定义

			{
				checkInterested();
				lastNeededUndonePieceChange = piecePicker.getNeededUndonePieceChange();
			}
			if (interested_in_other_peer && current_peer_state == 30)
				return true;
		}
		return false;
	}

	public int getPercentDoneInThousandNotation()
	{
		long total_done = getBytesDownloaded();
		return (int)((total_done * 1000L) / diskManager.getTotalLength());
	}

	public boolean transferAvailable()
	{
		return !choked_by_other_peer && interested_in_other_peer;
	}

	private void printRequestStats()
	{
		if (SHOW_DISCARD_RATE_STATS)
		{
			float discard_perc = ((float)requests_discarded * 100F) / ((float)(requests_completed + requests_recovered + requests_discarded) * 1.0F);
			float discard_perc_end = ((float)requests_discarded_endgame * 100F) / ((float)(requests_completed + requests_recovered + requests_discarded_endgame) * 1.0F);
			float recover_perc = ((float)requests_recovered * 100F) / ((float)(requests_recovered + requests_discarded) * 1.0F);
			System.out.println((new StringBuilder()).append("c=").append(requests_completed).append(" d=").append(requests_discarded).append(" de=").append(requests_discarded_endgame).append(" r=").append(requests_recovered).append(" dp=").append(discard_perc).append("% dpe=").append(discard_perc_end).append("% rp=").append(recover_perc).append("%").toString());
		}
	}

	private void checkSeed()
	{
		if (peerHavePieces != null && nbPieces > 0)
			setSeed(peerHavePieces.nbSet == nbPieces);
		else
			setSeed(false);
		if (manager.isSeeding() && isSeed())
			relativeSeeding |= 2;
		else
		if (manager.isSeeding() && (relativeSeeding & 1) != 0)
			relativeSeeding |= 2;
		else
		if (peerHavePieces != null && nbPieces > 0)
		{
			int piecesDone = manager.getPiecePicker().getNbPiecesDone();
			DiskManagerPiece dmPieces[] = diskManager.getPieces();
			boolean couldBeSeed = true;
			if (!manager.isSeeding() && (relativeSeeding & 1) != 0)
			{
				int i = peerHavePieces.start;
				do
				{
					if (i > peerHavePieces.end)
						break;
					couldBeSeed &= !peerHavePieces.flags[i] || dmPieces[i].isDone() || !dmPieces[i].isNeeded();
					if (!couldBeSeed)
						break;
					i++;
				} while (true);
			} else
			if (manager.isSeeding() && piecesDone <= peerHavePieces.nbSet)
			{
				int i = peerHavePieces.start;
				do
				{
					if (i > peerHavePieces.end)
						break;
					couldBeSeed &= !dmPieces[i].isDone() || peerHavePieces.flags[i];
					if (!couldBeSeed)
						break;
					i++;
				} while (true);
			} else
			{
				couldBeSeed = false;
			}
			if (couldBeSeed)
				relativeSeeding |= 2;
			else
				relativeSeeding &= 0xfd;
		} else
		{
			relativeSeeding &= 0xfd;
		}
	}

	public DiskManagerReadRequest request(int pieceNumber, int pieceOffset, int pieceLength)
	{
		DiskManagerReadRequest request;
		boolean added;
		request = manager.createDiskManagerRequest(pieceNumber, pieceOffset, pieceLength);
		if (current_peer_state != 30)
		{
			manager.requestCanceled(request);
			return null;
		}
		added = false;
		requested_mon.enter();
		if (!requested.contains(request))
		{
			requested.add(request);
			added = true;
		}
		requested_mon.exit();
		break MISSING_BLOCK_LABEL_93;
		Exception exception;
		exception;
		requested_mon.exit();
		throw exception;
		if (!added)
			break MISSING_BLOCK_LABEL_175;
		connection.getOutgoingMessageQueue().addMessage(new BTRequest(pieceNumber, pieceOffset, pieceLength, other_peer_request_version), false);
		_lastPiece = pieceNumber;
		recent_outgoing_requests_mon.enter();
		recent_outgoing_requests.put(request, null);
		recent_outgoing_requests_mon.exit();
		break MISSING_BLOCK_LABEL_172;
		Exception exception1;
		exception1;
		recent_outgoing_requests_mon.exit();
		throw exception1;
		return request;
		return null;
	}

	public int getRequestIndex(DiskManagerReadRequest request)
	{
		int i;
		requested_mon.enter();
		i = requested.indexOf(request);
		requested_mon.exit();
		return i;
		Exception exception;
		exception;
		requested_mon.exit();
		throw exception;
	}

	public void sendCancel(DiskManagerReadRequest request)
	{
		if (current_peer_state != 30)
			return;
		if (hasBeenRequested(request))
		{
			removeRequest(request);
			connection.getOutgoingMessageQueue().addMessage(new BTCancel(request.getPieceNumber(), request.getOffset(), request.getLength(), other_peer_cancel_version), false);
		}
	}

	public void sendHave(int pieceNumber)
	{
		if (current_peer_state != 30 || pieceNumber == manager.getHiddenPiece())
		{
			return;
		} else
		{
			boolean force = !other_peer_interested_in_me && peerHavePieces != null && !peerHavePieces.flags[pieceNumber];
			outgoing_have_message_aggregator.queueHaveMessage(pieceNumber, force || have_aggregation_disabled);
			checkInterested();
			return;
		}
	}

	public void sendChoke()
	{
		if (current_peer_state != 30)
			return;
		connection.getOutgoingMessageQueue().addMessage(new BTChoke(other_peer_choke_version), false);
		choking_other_peer = true;
		is_optimistic_unchoke = false;
		if (outgoing_piece_message_handler != null)
		{
			outgoing_piece_message_handler.removeAllPieceRequests();
			outgoing_piece_message_handler.destroy();
			outgoing_piece_message_handler = null;
		}
	}

	public void sendUnChoke()
	{
		if (current_peer_state != 30)
			return;
		if (outgoing_piece_message_handler == null)
			outgoing_piece_message_handler = new OutgoingBTPieceMessageHandler(this, connection.getOutgoingMessageQueue(), new OutgoingBTPieceMessageHandlerAdapter() {

				final PEPeerTransportProtocol this$0;

				public void diskRequestCompleted(long bytes)
				{
					peer_stats.diskReadComplete(bytes);
				}

			
			{
				this$0 = PEPeerTransportProtocol.this;
				super();
			}
			}, other_peer_piece_version);
		choking_other_peer = false;
		connection.getOutgoingMessageQueue().addMessage(new BTUnchoke(other_peer_unchoke_version), false);
	}

	private void sendKeepAlive()
	{
		if (current_peer_state != 30)
			return;
		if (outgoing_have_message_aggregator.hasPending())
			outgoing_have_message_aggregator.forceSendOfPending();
		else
			connection.getOutgoingMessageQueue().addMessage(new BTKeepAlive(other_peer_keep_alive_version), false);
	}

	private void sendMainlineDHTPort()
	{
		if (!ml_dht_enabled)
			return;
		MainlineDHTProvider provider = getDHTProvider();
		if (provider == null)
		{
			return;
		} else
		{
			Message message = new BTDHTPort(provider.getDHTPort());
			connection.getOutgoingMessageQueue().addMessage(message, false);
			return;
		}
	}

	public void checkInterested()
	{
		if (closing || peerHavePieces == null || peerHavePieces.nbSet == 0)
			return;
		boolean is_interesting = false;
		if (piecePicker.hasDownloadablePiece())
			if (!isSeed() && !isRelativeSeed())
			{
				int i = peerHavePieces.start;
				do
				{
					if (i > peerHavePieces.end)
						break;
					if (peerHavePieces.flags[i] && diskManager.isInteresting(i))
					{
						is_interesting = true;
						break;
					}
					i++;
				} while (true);
			} else
			{
				is_interesting = true;
			}
		if (is_interesting && !interested_in_other_peer)
			connection.getOutgoingMessageQueue().addMessage(new BTInterested(other_peer_interested_version), false);
		else
		if (!is_interesting && interested_in_other_peer)
			connection.getOutgoingMessageQueue().addMessage(new BTUninterested(other_peer_uninterested_version), false);
		interested_in_other_peer = is_interesting;
	}

	/**
	 * @deprecated Method sendBitField is deprecated
	 */

	private void sendBitField()
	{
		if (closing)
			return;
		if (manager.isSuperSeedMode())
			return;
		DirectByteBuffer buffer = DirectByteBufferPool.getBuffer((byte)12, (nbPieces + 7) / 8);
		DiskManagerPiece pieces[] = diskManager.getPieces();
		int num_pieces = pieces.length;
		HashSet lazies = null;
		int lazy_haves[] = null;
		if (ENABLE_LAZY_BITFIELD)
		{
			int bits_in_first_byte = Math.min(num_pieces, 8);
			int last_byte_start_bit = (num_pieces / 8) * 8;
			int bits_in_last_byte = num_pieces - last_byte_start_bit;
			if (bits_in_last_byte == 0)
			{
				bits_in_last_byte = 8;
				last_byte_start_bit -= 8;
			}
			lazies = new HashSet();
			int first_byte_entry = rnd.nextInt(bits_in_first_byte);
			if (pieces[first_byte_entry].isDone())
				lazies.add(new MutableInteger(first_byte_entry));
			int last_byte_entry = last_byte_start_bit + rnd.nextInt(bits_in_last_byte);
			if (pieces[last_byte_entry].isDone())
				lazies.add(new MutableInteger(last_byte_entry));
			int other_lazies = rnd.nextInt(16) + 4;
			for (int i = 0; i < other_lazies; i++)
			{
				int random_entry = rnd.nextInt(num_pieces);
				if (pieces[random_entry].isDone())
					lazies.add(new MutableInteger(random_entry));
			}

			int num_lazy = lazies.size();
			if (num_lazy == 0)
			{
				lazies = null;
			} else
			{
				lazy_haves = new int[num_lazy];
				Iterator it = lazies.iterator();
				for (int i = 0; i < num_lazy; i++)
				{
					int lazy_have = ((MutableInteger)it.next()).getValue();
					lazy_haves[i] = lazy_have;
				}

				if (num_lazy > 1)
				{
					for (int i = 0; i < num_lazy; i++)
					{
						int swap = rnd.nextInt(num_lazy);
						if (swap != i)
						{
							int temp = lazy_haves[swap];
							lazy_haves[swap] = lazy_haves[i];
							lazy_haves[i] = temp;
						}
					}

				}
			}
		}
		int bToSend = 0;
		int i = 0;
		MutableInteger mi = new MutableInteger(0);
		int hidden_piece = manager.getHiddenPiece();
		for (; i < num_pieces; i++)
		{
			if (i % 8 == 0)
				bToSend = 0;
			bToSend <<= 1;
			if (pieces[i].isDone() && i != hidden_piece)
				if (lazies != null)
				{
					mi.setValue(i);
					if (!lazies.contains(mi))
						bToSend++;
				} else
				{
					bToSend++;
				}
			if (i % 8 == 7)
				buffer.put((byte)6, (byte)bToSend);
		}

		if (i % 8 != 0)
		{
			bToSend <<= 8 - i % 8;
			buffer.put((byte)6, (byte)bToSend);
		}
		buffer.flip((byte)6);
		connection.getOutgoingMessageQueue().addMessage(new BTBitfield(buffer, other_peer_bitfield_version), false);
		if (lazy_haves != null)
		{
			final int f_lazy_haves[] = lazy_haves;
			SimpleTimer.addEvent("LazyHaveSender", SystemTime.getCurrentTime() + 1000L + (long)rnd.nextInt(2000), new TimerEventPerformer() {

				int next_have;
				final int val$f_lazy_haves[];
				final PEPeerTransportProtocol this$0;

				public void perform(TimerEvent event)
				{
					int lazy_have = f_lazy_haves[next_have++];
					if (current_peer_state == 30)
					{
						connection.getOutgoingMessageQueue().addMessage(new BTHave(lazy_have, other_peer_bt_have_version), false);
						if (next_have < f_lazy_haves.length && current_peer_state == 30)
							SimpleTimer.addEvent("LazyHaveSender", SystemTime.getCurrentTime() + (long)PEPeerTransportProtocol.rnd.nextInt(2000), this);
					}
				}

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

	public byte[] getId()
	{
		return peer_id;
	}

	public String getIp()
	{
		return ip;
	}

	public int getPort()
	{
		return port;
	}

	public int getTCPListenPort()
	{
		return tcp_listen_port;
	}

	public int getUDPListenPort()
	{
		return udp_listen_port;
	}

	public int getUDPNonDataListenPort()
	{
		return udp_non_data_port;
	}

	public String getClient()
	{
		return client;
	}