pepeercontrolimpl.java

java 文件下载器。可自定义

		{
			if (!it.hasNext())
				break;
			PEPeerTransport peer = (PEPeerTransport)it.next();
			if (peer.getIp().equals(address))
				result.add(peer);
		} while (true);
		return result;
	}

	public PeerDescriptor[] getPendingPeers()
	{
		return (PeerDescriptor[])peer_database.getDiscoveredPeers();
	}

	public PeerDescriptor[] getPendingPeers(String address)
	{
		return (PeerDescriptor[])peer_database.getDiscoveredPeers(address);
	}

	public void addPeer(PEPeer _transport)
	{
		if (!(_transport instanceof PEPeerTransport))
			throw new RuntimeException("invalid class");
		PEPeerTransport transport = (PEPeerTransport)_transport;
		if (!ip_filter.isInRange(transport.getIp(), getDisplayName(), getTorrentHash()))
		{
			ArrayList peer_transports = peer_transports_cow;
			if (!peer_transports.contains(transport))
			{
				addToPeerTransports(transport);
				transport.start();
			} else
			{
				Debug.out("addPeer():: peer_transports.contains(transport): SHOULD NEVER HAPPEN !");
				transport.closeConnection("already connected");
			}
		} else
		{
			transport.closeConnection("IP address blocked by filters");
		}
	}

	protected byte[] getTorrentHash()
	{
		return disk_mgr.getTorrent().getHash();
		Throwable e;
		e;
		return null;
	}

	public void removePeer(PEPeer _transport)
	{
		removePeer(_transport, "remove peer");
	}

	public void removePeer(PEPeer _transport, String reason)
	{
		if (!(_transport instanceof PEPeerTransport))
		{
			throw new RuntimeException("invalid class");
		} else
		{
			PEPeerTransport transport = (PEPeerTransport)_transport;
			closeAndRemovePeer(transport, reason, true);
			return;
		}
	}

	private void closeAndRemovePeer(PEPeerTransport peer, String reason, boolean log_if_not_found)
	{
		boolean removed = false;
		peer_transports_mon.enter();
		if (peer_transports_cow.contains(peer))
		{
			ArrayList new_peer_transports = new ArrayList(peer_transports_cow);
			new_peer_transports.remove(peer);
			peer_transports_cow = new_peer_transports;
			removed = true;
		}
		peer_transports_mon.exit();
		break MISSING_BLOCK_LABEL_72;
		Exception exception;
		exception;
		peer_transports_mon.exit();
		throw exception;
		if (removed)
		{
			peer.closeConnection(reason);
			peerRemoved(peer);
		} else
		if (!log_if_not_found);
		return;
	}

	private void closeAndRemoveAllPeers(String reason, boolean reconnect)
	{
		ArrayList peer_transports;
		peer_transports_mon.enter();
		peer_transports = peer_transports_cow;
		peer_transports_cow = new ArrayList(0);
		peer_transports_mon.exit();
		break MISSING_BLOCK_LABEL_46;
		Exception exception;
		exception;
		peer_transports_mon.exit();
		throw exception;
		for (int i = 0; i < peer_transports.size(); i++)
		{
			PEPeerTransport peer = (PEPeerTransport)peer_transports.get(i);
			try
			{
				peer.closeConnection(reason);
			}
			catch (Throwable e)
			{
				Debug.printStackTrace(e);
			}
			try
			{
				peerRemoved(peer);
			}
			catch (Throwable e)
			{
				Debug.printStackTrace(e);
			}
		}

		if (reconnect)
		{
			for (int i = 0; i < peer_transports.size(); i++)
			{
				PEPeerTransport peer = (PEPeerTransport)peer_transports.get(i);
				PEPeerTransport reconnected_peer = peer.reconnect(false);
			}

		}
		return;
	}

	public void addPeer(String ip_address, int tcp_port, int udp_port, boolean use_crypto, Map user_data)
	{
		byte type = ((byte)(use_crypto ? 1 : 0));
		PeerItem peer_item = PeerItemFactory.createPeerItem(ip_address, tcp_port, PeerItem.convertSourceID("Plugin"), type, udp_port, (byte)1, 0);
		byte crypto_level = 1;
		if (!isAlreadyConnected(peer_item))
		{
			boolean tcp_ok = TCPNetworkManager.TCP_OUTGOING_ENABLED && tcp_port > 0;
			boolean udp_ok = UDPNetworkManager.UDP_OUTGOING_ENABLED && udp_port > 0;
			String fail_reason;
			if (tcp_ok && (!prefer_udp && !prefer_udp_default || !udp_ok))
				fail_reason = makeNewOutgoingConnection("Plugin", ip_address, tcp_port, udp_port, true, use_crypto, crypto_level, user_data);
			else
			if (udp_ok)
				fail_reason = makeNewOutgoingConnection("Plugin", ip_address, tcp_port, udp_port, false, use_crypto, crypto_level, user_data);
			else
				fail_reason = "No usable protocol";
			if (fail_reason != null)
				Debug.out((new StringBuilder()).append("Injected peer ").append(ip_address).append(":").append(tcp_port).append(" was not added - ").append(fail_reason).toString());
		}
	}

	private void addPeersFromTracker(TRTrackerAnnouncerResponsePeer peers[])
	{
		for (int i = 0; i < peers.length; i++)
		{
			TRTrackerAnnouncerResponsePeer peer = peers[i];
			ArrayList peer_transports = peer_transports_cow;
			boolean already_connected = false;
			for (int x = 0; x < peer_transports.size(); x++)
			{
				PEPeerTransport transport = (PEPeerTransport)peer_transports.get(x);
				if (!peer.getAddress().equals(transport.getIp()))
					continue;
				boolean same_allowed = COConfigurationManager.getBooleanParameter("Allow Same IP Peers") || transport.getIp().equals("127.0.0.1");
				if (same_allowed && peer.getPort() != transport.getPort())
					continue;
				already_connected = true;
				break;
			}

			if (already_connected)
				continue;
			if (peer_database != null)
			{
				byte type = ((byte)(peer.getProtocol() != 2 ? 0 : 1));
				byte crypto_level = ((byte)(peer.getAZVersion() >= 3 ? 2 : 1));
				PeerItem item = PeerItemFactory.createPeerItem(peer.getAddress(), peer.getPort(), PeerItem.convertSourceID(peer.getSource()), type, peer.getUDPPort(), crypto_level, peer.getUploadSpeed());
				peerDiscovered(null, item);
				peer_database.addDiscoveredPeer(item);
			}
			int http_port = peer.getHTTPPort();
			if (http_port != 0)
				adapter.addHTTPSeed(peer.getAddress(), http_port);
		}

	}

	private String makeNewOutgoingConnection(String peer_source, String address, int tcp_port, int udp_port, boolean use_tcp, boolean require_crypto, byte crypto_level, 
			Map user_data)
	{
		if (ip_filter.isInRange(address, getDisplayName(), getTorrentHash()))
			return "IPFilter block";
		int needed = getMaxNewConnectionsAllowed();
		boolean is_priority_connection = false;
		if (user_data != null)
		{
			Boolean pc = (Boolean)user_data.get(Peer.PR_PRIORITY_CONNECTION);
			if (pc != null && pc.booleanValue())
				is_priority_connection = true;
		}
		if (needed == 0 && (peer_source != "Plugin" || !doOptimisticDisconnect(AddressUtils.isLANLocalAddress(address) != 2, is_priority_connection)))
			return "Too many connections";
		boolean same_allowed = COConfigurationManager.getBooleanParameter("Allow Same IP Peers") || address.equals("127.0.0.1");
		if (!same_allowed && PeerIdentityManager.containsIPAddress(_hash, address))
			return "Already connected to IP";
		if (PeerUtils.ignorePeerPort(tcp_port))
		{
			if (Logger.isEnabled())
				Logger.log(new LogEvent(disk_mgr.getTorrent(), LOGID, (new StringBuilder()).append("Skipping connect with ").append(address).append(":").append(tcp_port).append(" as peer port is in ignore list.").toString()));
			return "TCP port in ignore list";
		} else
		{
			PEPeerTransport real = PEPeerTransportFactory.createTransport(this, peer_source, address, tcp_port, udp_port, use_tcp, require_crypto, crypto_level, user_data);
			addToPeerTransports(real);
			return null;
		}
	}

	private void checkCompletedPieces()
	{
		if (mainloop_loop_count % (long)MAINLOOP_ONE_SECOND_INTERVAL != 0L)
			return;
		for (int i = 0; i < _nbPieces; i++)
		{
			DiskManagerPiece dmPiece = dm_pieces[i];
			if (dmPiece.isNeedsCheck())
			{
				dmPiece.setChecking();
				DiskManagerCheckRequest req = disk_mgr.createCheckRequest(i, new Integer(1));
				req.setAdHoc(false);
				disk_mgr.enqueueCheckRequest(req, this);
			}
		}

	}

	private boolean checkEmptyPiece(int pieceNumber)
	{
		if (piecePicker.isInEndGameMode())
			return false;
		PEPiece pePiece = pePieces[pieceNumber];
		DiskManagerPiece dmPiece = dm_pieces[pieceNumber];
		if (pePiece == null || pePiece.isRequested())
			return false;
		if (dmPiece.getNbWritten() > 0 || pePiece.getNbUnrequested() < pePiece.getNbBlocks() || pePiece.getReservedBy() != null)
		{
			return false;
		} else
		{
			pePiece.reset();
			removePiece(pePiece, pieceNumber);
			return true;
		}
	}

	private void checkSpeedAndReserved()
	{
		if (mainloop_loop_count % (long)MAINLOOP_FIVE_SECOND_INTERVAL != 0L)
			return;
		int nbPieces = _nbPieces;
		PEPieceImpl pieces[] = pePieces;
		for (int i = 0; i < nbPieces; i++)
		{
			checkEmptyPiece(i);
			PEPieceImpl pePiece = pieces[i];
			if (pePiece == null)
				continue;
			long timeSinceActivity = pePiece.getTimeSinceLastActivity() / 1000L;
			int pieceSpeed = pePiece.getSpeed();
			if (pieceSpeed > 0 && (double)(timeSinceActivity * (long)pieceSpeed) * 0.25D > 16D)
				if (pePiece.getNbUnrequested() > 2)
					pePiece.setSpeed(pieceSpeed - 1);
				else
					pePiece.setSpeed(0);
			if (timeSinceActivity <= 120L)
				continue;
			pePiece.setSpeed(0);
			String reservingPeer = pePiece.getReservedBy();
			if (reservingPeer != null)
			{
				PEPeerTransport pt = getTransportFromAddress(reservingPeer);
				if (needsMD5CheckOnCompletion(i))
					badPeerDetected(reservingPeer, i);
				else
				if (pt != null)
					closeAndRemovePeer(pt, "Reserved piece data timeout; 120 seconds", true);
				pePiece.setReservedBy(null);
			}
			if (!piecePicker.isInEndGameMode())
				pePiece.checkRequests();
			checkEmptyPiece(i);
		}

	}

	private void check99PercentBug()
	{
		if (mainloop_loop_count % (long)MAINLOOP_SIXTY_SECOND_INTERVAL == 0L)
		{
			long now = SystemTime.getCurrentTime();
			for (int i = 0; i < pePieces.length; i++)
			{
				PEPiece pe_piece = pePieces[i];
				if (pe_piece == null)
					continue;
				DiskManagerPiece dm_piece = dm_pieces[i];
				if (!dm_piece.isDone() && pe_piece.isDownloaded() && now - pe_piece.getLastDownloadTime(now) > (long)stalled_piece_timeout && !disk_mgr.hasOutstandingWriteRequestForPiece(i) && !disk_mgr.hasOutstandingReadRequestForPiece(i) && !disk_mgr.hasOutstandingCheckRequestForPiece(i))
				{
					Debug.out((new StringBuilder()).append("Fully downloaded piece stalled pending write, resetting p_piece ").append(i).toString());
					pe_piece.reset();
				}
			}

		}
	}

	private void checkInterested()
	{
		if (mainloop_loop_count % (long)MAINLOOP_ONE_SECOND_INTERVAL != 0L)
			return;
		if (lastNeededUndonePieceChange >= piecePicker.getNeededUndonePieceChange())
			return;
		lastNeededUndonePieceChange = piecePicker.getNeededUndonePieceChange();
		ArrayList peer_transports = peer_transports_cow;
		int cntPeersSnubbed = 0;
		for (int i = 0; i < peer_transports.size(); i++)
		{
			PEPeerTransport peer = (PEPeerTransport)peer_transports.get(i);
			peer.checkInterested();
			if (peer.isSnubbed())
				cntPeersSnubbed++;
		}

		setNbPeersSnubbed(cntPeersSnubbed);
	}

	private void processPieceChecks()
	{
		if (piece_check_result_list.size() <= 0)
			break MISSING_BLOCK_LABEL_111;
		List pieces;
		piece_check_result_list_mon.enter();
		pieces = new ArrayList(piece_check_result_list);
		piece_check_result_list.clear();
		piece_check_result_list_mon.exit();
		break MISSING_BLOCK_LABEL_60;
		Exception exception;
		exception;
		piece_check_result_list_mon.exit();
		throw exception;
		Object data[];
		for (Iterator it = pieces.iterator(); it.hasNext(); processPieceCheckResult((DiskManagerCheckRequest)data[0], ((Integer)data[1]).intValue()))
			data = (Object[])(Object[])it.next();

	}

	private void checkBadPieces()
	{
		if (mainloop_loop_count % (long)MAINLOOP_SIXTY_SECOND_INTERVAL == 0L && bad_piece_reported != -1)
		{
			DiskManagerCheckRequest req = disk_mgr.createCheckRequest(bad_piece_reported, new Integer(5));
			req.setLowPriority(true);
			if (Logger.isEnabled())
				Logger.log(new LogEvent(disk_mgr.getTorrent(), LOGID, (new StringBuilder()).append("Rescanning reported-bad piece ").append(bad_piece_reported).toString()));
			bad_piece_reported = -1;
			try
			{
				disk_mgr.enqueueCheckRequest(req, this);
			}
			catch (Throwable e)
			{
				Debug.printStackTrace(e);
			}
		}
	}

	private void checkRescan()
	{
		if (rescan_piece_time == 0L)
			return;
		if (next_rescan_piece == -1)
		{
			if (mainloop_loop_count % (long)MAINLOOP_FIVE_SECOND_INTERVAL == 0L && adapter.isPeriodicRescanEnabled())
				next_rescan_piece = 0;
		} else
		if (mainloop_loop_count % (long)MAINLOOP_TEN_MINUTE_INTERVAL == 0L && !adapter.isPeriodicRescanEnabled())
			next_rescan_piece = -1;
		if (next_rescan_piece == -1)
			return;
		long now = SystemTime.getCurrentTime();
		if (rescan_piece_time > now)
			rescan_piece_time = now;
		long piece_size = disk_mgr.getPieceLength();
		long millis_per_piece = piece_size / 250L;
		if (now - rescan_piece_time < millis_per_piece)
			return;
		do
		{
			if (next_rescan_piece == -1)
				break;
			int this_piece = next_rescan_piece;
			next_rescan_piece++;
			if (next_rescan_piece == _nbPieces)
				next_rescan_piece = -1;
			if (pePieces[this_piece] != null || dm_pieces[this_piece].isDone() || !dm_pieces[this_piece].isNeeded())
				continue;
			DiskManagerCheckRequest req = disk_mgr.createCheckRequest(this_piece, new Integer(3));
			req.setLowPriority(true);
			if (Logger.isEnabled())
				Logger.log(new LogEvent(disk_mgr.getTorrent(), LOGID, (new StringBuilder()).append("Rescanning piece ").append(this_piece).toString()));
			rescan_piece_time = 0L;
			try
			{
				disk_mgr.enqueueCheckRequest(req, this);
			}
			catch (Throwable e)
			{