trtrackerservertorrentimpl.java

java 文件下载器。可自定义

			boolean bad_nat;
			boolean is_seed;
			TRTrackerServerException e;
			Exception exception;
			try
			{
				this_mon.enter();
				handleRedirects(url_parameters, ip_address, false);
				event_type = 2;
				if (event != null && event.length() > 2)
				{
					char c = event.charAt(2);
					if (c == 'm')
						event_type = 3;
					else
					if (c == 'o')
						event_type = 4;
					else
						event_type = 1;
				}
				now = SystemTime.getCurrentTime();
				tracker_key_hash_code = tracker_key != null ? tracker_key.hashCode() : 0;
				peer = (TRTrackerServerPeerImpl)peer_map.get(peer_id);
				new_peer = false;
				peer_already_removed = false;
				already_completed = false;
				last_contact_time = 0L;
				ul_diff = 0L;
				dl_diff = 0L;
				le_diff = 0L;
				ip_address_bytes = ip_address.getBytes("ISO-8859-1");
				if (peer != null)
					break MISSING_BLOCK_LABEL_785;
				reuse_key = (new StringBuilder()).append(new String(ip_address_bytes, "ISO-8859-1")).append(":").append(tcp_port).toString();
				last_NAT_status = ((byte)(loopback ? 3 : 0));
				new_peer = true;
				TRTrackerServerPeerImpl old_peer = (TRTrackerServerPeerImpl)peer_reuse_map.get(reuse_key);
				if (old_peer != null)
				{
					if (ip_override && !old_peer.isIPOverride())
						throw new TRTrackerServerException((new StringBuilder()).append("IP Override denied (existing '").append(reuse_key).append("' is not override)").toString());
					last_contact_time = old_peer.getLastContactTime();
					already_completed = old_peer.getDownloadCompleted();
					removePeer(old_peer, 5, null);
					lightweight_seed_map.remove(old_peer.getPeerId());
				} else
				{
					lightweightSeed lws = (lightweightSeed)lightweight_seed_map.remove(peer_id);
					if (lws != null)
					{
						last_contact_time = lws.getLastContactTime();
						ul_diff = uploaded - lws.getUploaded();
						if (ul_diff < 0L)
							ul_diff = 0L;
						last_NAT_status = lws.getNATStatus();
					} else
					{
						last_contact_time = now;
					}
				}
				if (event_type == 4)
					break MISSING_BLOCK_LABEL_1139;
				biased_peer_set = server.getBiasedPeers();
				biased = biased_peer_set != null && biased_peer_set.contains(ip_address);
				if (!ip_override || ip_override_count < 64 || loopback || biased)
					break label0;
				if (!ip_override_limit_exceeded_reported)
				{
					ip_override_limit_exceeded_reported = true;
					Debug.out((new StringBuilder()).append("Too many ip-override peers for ").append(ByteFormatter.encodeString(hash.getBytes())).toString());
				}
				it = null;
			}
			catch (UnsupportedEncodingException e)
			{
				throw new TRTrackerServerException("Encoding fails", e);
			}
			finally
			{
				this_mon.exit();
				throw exception1;
			}
			this_mon.exit();
			return it;
		}
		peer = new TRTrackerServerPeerImpl(peer_id, tracker_key_hash_code, ip_address_bytes, ip_override, tcp_port, udp_port, http_port, crypto_level, az_ver, last_contact_time, already_completed, last_NAT_status, up_speed, network_position);
		if (ip_override)
		{
			if (biased && !biased_peer_set.contains(original_address))
				throw new TRTrackerServerException((new StringBuilder()).append("IP Override denied (you are ").append(original_address).append(")").toString());
			ip_override_count++;
		}
		peer_map.put(peer_id, peer);
		peer_list.add(peer);
		peer_reuse_map.put(reuse_key, peer);
		if (biased)
		{
			peer.setBiased(true);
			if (biased_peers == null)
				biased_peers = new ArrayList();
			biased_peers.add(peer);
		}
		if (queued_peers == null)
			break MISSING_BLOCK_LABEL_1139;
		if (peer_map.size() > 32)
		{
			queued_peers = null;
			break MISSING_BLOCK_LABEL_1139;
		}
		it = queued_peers.iterator();
		do
		{
			if (!it.hasNext())
				break MISSING_BLOCK_LABEL_1139;
			qp = (QueuedPeer)it.next();
		} while (!qp.sameAs(peer));
		it.remove();
		break MISSING_BLOCK_LABEL_1139;
		existing_tracker_key_hash_code = peer.getKeyHashCode();
		if (existing_tracker_key_hash_code != tracker_key_hash_code)
			throw new TRTrackerServerException("Unauthorised: key mismatch ");
		if (ip_override)
		{
			if (peer.isBiased())
			{
				biased_peer_set = server.getBiasedPeers();
				if (biased_peer_set == null || !biased_peer_set.contains(original_address))
					throw new TRTrackerServerException((new StringBuilder()).append("IP Override denied (you are ").append(original_address).append(")").toString());
			}
			if (!peer.isIPOverride())
				throw new TRTrackerServerException("IP Override denied (existing entry not override)");
		}
		already_completed = peer.getDownloadCompleted();
		last_contact_time = peer.getLastContactTime();
		if (event_type == 4)
		{
			removePeer(peer, event_type, url_parameters);
			peer_already_removed = true;
		} else
		{
			old_ip = peer.getIPAsRead();
			old_port = peer.getTCPPort();
			if (peer.update(ip_address_bytes, tcp_port, udp_port, http_port, crypto_level, az_ver, up_speed, network_position))
			{
				old_key = (new StringBuilder()).append(new String(old_ip, "ISO-8859-1")).append(":").append(old_port).toString();
				new_key = (new StringBuilder()).append(new String(ip_address_bytes, "ISO-8859-1")).append(":").append(tcp_port).toString();
				old_peer = (TRTrackerServerPeerImpl)peer_reuse_map.get(new_key);
				if (old_peer != null)
					removePeer(old_peer, 5, null);
				if (peer_reuse_map.remove(old_key) == null)
					Debug.out((new StringBuilder()).append("TRTrackerServerTorrent: IP address change: '").append(old_key).append("' -> '").append(new_key).append("': old key not found").toString());
				peer_reuse_map.put(new_key, peer);
			}
		}
		new_timeout = now + interval_requested * 1000L * 3L;
		if (peer != null)
		{
			peer.setTimeout(now, new_timeout);
			if (!new_peer)
			{
				ul_diff = uploaded - peer.getUploaded();
				dl_diff = downloaded - peer.getDownloaded();
			}
			elapsed_time = now - last_contact_time;
			if (elapsed_time == 0L)
				elapsed_time = 25L;
			ul_rate = (ul_diff * 1000L) / elapsed_time;
			dl_rate = (dl_diff * 1000L) / elapsed_time;
			if (ul_rate > 0x300000L)
			{
				if (Logger.isEnabled())
					Logger.log(new LogEvent(LOGID, (new StringBuilder()).append("TRTrackerPeer: peer ").append(peer.getIPRaw()).append("/").append(new String(peer.getPeerId().getHash())).append(" reported an upload rate of ").append(ul_rate / 1024L).append(" KiB/s per second").toString()));
				ul_diff = 0L;
			}
			if (dl_rate > 0x300000L)
			{
				if (Logger.isEnabled())
					Logger.log(new LogEvent(LOGID, (new StringBuilder()).append("TRTrackerPeer: peer ").append(peer.getIPRaw()).append("/").append(new String(peer.getPeerId().getHash())).append(" reported a download rate of ").append(dl_rate / 1024L).append(" KiB/s per second").toString()));
				dl_diff = 0L;
			}
			le_diff = event_type != 4 ? left - peer.getAmountLeft() : 0L;
			was_seed = new_peer ? false : peer.isSeed();
			peer.setStats(uploaded, downloaded, left);
			is_seed = peer.isSeed();
			if (event_type != 4 && !was_seed && is_seed)
				seed_count++;
			if (!peer_already_removed)
				try
				{
					peerEvent(peer, event_type, url_parameters);
				}
				// Misplaced declaration of an exception variable
				catch (TRTrackerServerException e)
				{
					deferred_failure = e;
				}
		}
		stats.addAnnounce(ul_diff, dl_diff, le_diff, peer != null && peer.isBiased());
		if (event_type == 3 && !already_completed)
		{
			peer.setDownloadCompleted();
			stats.addCompleted();
		}
		if (peer == null || !peer.isSeed())
			break MISSING_BLOCK_LABEL_1877;
		seed_limit = TRTrackerServerImpl.getSeedLimit();
		if (seed_limit != 0 && seed_count > seed_limit && !loopback)
		{
			if (!peer_already_removed)
				removePeer(peer, 6, null);
			throw new TRTrackerServerException("too many seeds");
		}
		seed_retention = TRTrackerServerImpl.getMaxSeedRetention();
		if (seed_retention == 0 || seed_count <= seed_retention)
			break MISSING_BLOCK_LABEL_1877;
		to_remove = seed_retention / 20 + 1;
		peer_list_compaction_suspended = true;
		bad_nat_loop = TRTrackerServerNATChecker.getSingleton().isEnabled() ? 0 : 1;
		do
		{
			if (bad_nat_loop >= 2)
				break;
			for (i = 0; i < peer_list.size(); i++)
			{
				this_peer = (TRTrackerServerPeerImpl)peer_list.get(i);
				if (this_peer == null || !this_peer.isSeed() || this_peer.isBiased())
					continue;
				bad_nat = this_peer.isNATStatusBad();
				if ((bad_nat_loop != 0 || !bad_nat) && bad_nat_loop != 1)
					continue;
				lightweight_seed_map.put(this_peer.getPeerId(), new lightweightSeed(now, new_timeout, this_peer.getUploaded(), this_peer.getNATStatus()));
				removePeer(this_peer, i, 6, null);
				if (--to_remove == 0)
					break;
			}

			if (to_remove == 0)
				break;
			bad_nat_loop++;
		} while (true);
		peer_list_compaction_suspended = false;
		break MISSING_BLOCK_LABEL_1872;
		exception;
		peer_list_compaction_suspended = false;
		throw exception;
		checkForPeerListCompaction(false);
		if (deferred_failure != null)
		{
			if (peer != null && !peer_already_removed)
				removePeer(peer, 7, url_parameters);
			throw deferred_failure;
		}
		trtrackerserverpeerimpl = peer;
		this_mon.exit();
		return trtrackerserverpeerimpl;
	}

	public void peerQueued(String ip, int tcp_port, int udp_port, int http_port, byte crypto_level, byte az_ver, long timeout_secs, boolean seed)
	{
		if (peer_map.size() >= 32 || tcp_port == 0)
			return;
		QueuedPeer new_qp;
		String reuse_key;
		this_mon.enter();
		Set biased_peer_set = server.getBiasedPeers();
		boolean biased = biased_peer_set != null && biased_peer_set.contains(ip);
		new_qp = new QueuedPeer(ip, tcp_port, udp_port, http_port, crypto_level, az_ver, (int)timeout_secs, seed, biased);
		reuse_key = (new StringBuilder()).append(new_qp.getIP()).append(":").append(tcp_port).toString();
		if (peer_reuse_map.containsKey(reuse_key))
		{
			this_mon.exit();
			return;
		}
		boolean add;
		Iterator it;
		add = true;
		if (queued_peers == null)
			break MISSING_BLOCK_LABEL_326;
		it = queued_peers.iterator();
		QueuedPeer qp;
		do
		{
			if (!it.hasNext())
				break MISSING_BLOCK_LABEL_213;
			qp = (QueuedPeer)it.next();
		} while (!qp.sameAs(new_qp));
		it.remove();
		queued_peers.add(new_qp);
		this_mon.exit();
		return;
		if (queued_peers.size() >= 32)
		{
			QueuedPeer oldest = null;
			it = queued_peers.iterator();
			do
			{
				if (!it.hasNext())
					break;
				QueuedPeer qp = (QueuedPeer)it.next();
				if (!qp.isBiased())
					if (oldest == null)
						oldest = qp;
					else
					if (qp.getCreateTime() < oldest.getCreateTime())
						oldest = qp;
			} while (true);
			if (oldest == null)
				add = false;
			else
				queued_peers.remove(oldest);
		}
		break MISSING_BLOCK_LABEL_337;
		queued_peers = new LinkedList();
		if (add)
			queued_peers.addFirst(new_qp);
		this_mon.exit();
		break MISSING_BLOCK_LABEL_373;
		Exception exception;
		exception;
		this_mon.exit();
		throw exception;
	}

	public void remove(TRTrackerServerPeerBase peer)
	{
		this_mon.enter();
		if (peer instanceof TRTrackerServerPeerImpl)
		{
			TRTrackerServerPeerImpl pi = (TRTrackerServerPeerImpl)peer;
			if (peer_map.containsKey(pi.getPeerId()))
			{
				int index = peer_list.indexOf(pi);
				if (index != -1)
					removePeer(pi, index, 7, null);
			}
		} else
		if (queued_peers != null)
		{
			queued_peers.remove(peer);
			if (queued_peers.size() == 0)
				queued_peers = null;
		}
		this_mon.exit();
		break MISSING_BLOCK_LABEL_116;
		Exception exception;
		exception;
		this_mon.exit();
		throw exception;
	}

	protected void removePeer(TRTrackerServerPeerImpl peer, int reason, String url_parameters)
	{
		removePeer(peer, -1, reason, url_parameters);
	}

	protected void removePeer(TRTrackerServerPeerImpl peer, int peer_list_index, int reason, String url_parameters)
	{
		this_mon.enter();
		if (peer.isIPOverride())
			ip_override_count--;
		stats.removeLeft(peer.getAmountLeft());
		if (peer_map.size() != peer_reuse_map.size() && !map_size_diff_reported)
		{
			map_size_diff_reported = true;
			Debug.out((new StringBuilder()).append("TRTrackerServerTorrent::removePeer: maps size different ( ").append(peer_map.size()).append("/").append(peer_reuse_map.size()).append(")").toString());
		}
		Object o = peer_map.remove(peer.getPeerId());
		if (o == null)
			Debug.out(" TRTrackerServerTorrent::removePeer: peer_map doesn't contain peer");
		else
			try
			{
				peerEvent(peer, reason, url_parameters);
			}
			catch (TRTrackerServerException e) { }
		if (peer_list_index == -1)
		{
			int peer_index = peer_list.indexOf(peer);
			if (peer_index == -1)
				Debug.out(" TRTrackerServerTorrent::removePeer: peer_list doesn't contain peer");
			else
				peer_list.set(peer_index, null);
		} else
		if (peer_list.get(peer_list_index) == peer)
			peer_list.set(peer_list_index, null);
		else
			Debug.out(" TRTrackerServerTorrent::removePeer: peer_list doesn't contain peer at index");
		peer_list_hole_count++;
		checkForPeerListCompaction(false);
		try
		{
			peer_index = ((int) (peer_reuse_map.remove((new StringBuilder()).append(new String(peer.getIPAsRead(), "ISO-8859-1")).append(":").append(peer.getTCPPort()).toString())));
			if (peer_index == null)
				Debug.out(" TRTrackerServerTorrent::removePeer: peer_reuse_map doesn't contain peer");
		}
		catch (UnsupportedEncodingException e) { }
		if (biased_peers != null)
			biased_peers.remove(peer);
		if (peer.isSeed())
			seed_count--;
		removed_count++;
		this_mon.exit();
		break MISSING_BLOCK_LABEL_388;
		Exception exception;
		exception;
		this_mon.exit();
		throw exception;
	}

	protected void updateBiasedPeers(Set biased_peers_set)
	{
		this_mon.enter();
		Iterator it = peer_list.iterator();
		if (it.hasNext() && biased_peers == null)
			biased_peers = new ArrayList();
		do
		{
			if (!it.hasNext())
				break;
			TRTrackerServerPeerImpl this_peer = (TRTrackerServerPeerImpl)it.next();
			if (this_peer != null)
			{
				boolean biased = biased_peers_set.contains(this_peer.getIPRaw());
				this_peer.setBiased(biased);
				if (biased)
				{
					if (!biased_peers.contains(this_peer))
						biased_peers.add(this_peer);
				} else
				{
					biased_peers.remove(this_peer);
				}
			}
		} while (true);
		if (queued_peers != null)
		{
			QueuedPeer peer;
			for (it = queued_peers.iterator(); it.hasNext(); peer.setBiased(biased_peers_set.contains(peer.getIP())))
				peer = (QueuedPeer)it.next();

		}
		this_mon.exit();
		break MISSING_BLOCK_LABEL_204;
		Exception exception;
		exception;
		this_mon.exit();
		throw exception;
	}

	public TRTrackerServerTorrent addLink(String link)
	{
		return server.addLink(link, this);
	}

	public void removeLink(String link)
	{
		server.removeLink(link, this);
	}

	public Map exportAnnounceToMap(String ip_address, HashMap preprocess_map, TRTrackerServerPeerImpl requesting_peer, boolean include_seeds, int num_want, long interval, 
			long min_interval, boolean no_peer_id, byte compact_mode, byte crypto_level, DHTNetworkPosition network_position)
	{
		long now;
		boolean nat_warning;
		int total_peers;
		int cache_millis;
		boolean send_peer_ids;
		boolean add_to_cache;
		List explicit_limited_peers;
		List explicit_biased_peers;
		Set remove_ips;
		boolean requester_is_biased;
		int i;
		this_mon.enter();
		now = SystemTime.getCurrentTime();
		nat_warning = requesting_peer != null && requesting_peer.getNATStatus() == 4;
		total_peers = this.peer_map.size();
		cache_millis = TRTrackerServerImpl.getAnnounceCachePeriod();
		send_peer_ids = TRTrackerServerImpl.getSendPeerIds();
		if (no_peer_id || compact_mode != 0)
			send_peer_ids = false;
		add_to_cache = false;
		int max_peers = TRTrackerServerImpl.getMaxPeersToSend();
		if (num_want < 0)
			num_want = total_peers;
		if (max_peers > 0 && num_want > max_peers)
			num_want = max_peers;
		explicit_limited_peers = null;
		explicit_biased_peers = null;
		remove_ips = null;
		if (requesting_peer != null && peer_listeners != null)
		{
			for (int i = 0; i < peer_listeners.size(); i++)
				try
				{
					Map reply = ((TRTrackerServerTorrentPeerListener)peer_listeners.get(i)).eventOccurred(this, requesting_peer, 8, null);
					if (reply == null)
						continue;
					List limited_peers = (List)reply.get("limited_peers");
					if (limited_peers != null)
					{
						if (explicit_limited_peers == null)
							explicit_limited_peers = new ArrayList();
						for (int j = 0; j < limited_peers.size(); j++)
						{
							Map peer_map = (Map)limited_peers.get(j);
							String ip = (String)peer_map.get("ip");
							int port = ((Long)peer_map.get("port")).intValue();
							String reuse_key = (new StringBuilder()).append(ip).append(":").append(port).toString();
							TRTrackerServerPeerImpl peer = (TRTrackerServerPeerImpl)peer_reuse_map.get(reuse_key);
							if (peer != null && !explicit_limited_peers.contains(peer))
								explicit_limited_peers.add(peer);
						}