trtrackerservertorrentimpl.java

java 文件下载器。可自定义

					byte compact_peers_v4[] = new byte[num_ipv4 * 6];
					byte compact_peers_v6[] = new byte[num_ipv6 * 18];
					it = rep_peers.iterator();
					int v4_index = 0;
					int v6_index = 0;
					while (it.hasNext()) 
					{
						Map rep_peer = (Map)it.next();
						byte ip[] = (byte[])(byte[])rep_peer.get("ip");
						int port = ((Long)rep_peer.get("port")).intValue();
						if (ip.length > 4)
						{
							int pos = v6_index * 18;
							System.arraycopy(ip, 0, compact_peers_v6, pos, 16);
							pos += 16;
							compact_peers_v6[pos++] = (byte)(port >> 8);
							compact_peers_v6[pos++] = (byte)(port & 0xff);
							v6_index++;
						} else
						{
							int pos = v4_index * 6;
							System.arraycopy(ip, 0, compact_peers_v4, pos, 4);
							pos += 4;
							compact_peers_v4[pos++] = (byte)(port >> 8);
							compact_peers_v4[pos++] = (byte)(port & 0xff);
							v4_index++;
						}
					}
					if (compact_peers_v4.length > 0)
						root.put("peers", compact_peers_v4);
					if (compact_peers_v6.length > 0)
						root.put("peers6", compact_peers_v6);
				} else
				{
					root.put("peers", compact_peers);
				}
			} else
			{
				for (int index = 0; it.hasNext(); index++)
				{
					Map rep_peer = (Map)it.next();
					if (crypto_flags != null)
					{
						Long crypto_flag = (Long)rep_peer.remove("crypto_flag");
						crypto_flags[index] = crypto_flag.byteValue();
					}
				}

				root.put("peers", rep_peers);
			}
			if (crypto_flags != null)
				root.put("crypto_flags", crypto_flags);
		}
		root.put("interval", new Long(interval));
		root.put("min interval", new Long(min_interval));
		if (nat_warning)
		{
			requesting_peer.setNATStatus((byte)5);
			root.put("warning message", (new StringBuilder()).append("Unable to connect to your incoming data port (").append(requesting_peer.getIP()).append(":").append(requesting_peer.getTCPPort()).append("). ").append("This will result in slow downloads. Please check your firewall/router settings").toString().getBytes());
		}
		root.put("complete", new Long(getSeedCountForScrape(requester_is_biased)));
		root.put("incomplete", new Long(getLeecherCount()));
		root.put("downloaded", new Long(stats.getCompletedCount()));
		if (add_to_cache)
			announce_cache.put(new Integer((num_peers_returned + 9) / 10), new announceCacheEntry(root, send_peer_ids, compact_mode));
		map = root;
		this_mon.exit();
		return map;
		Exception exception1;
		exception1;
		this_mon.exit();
		throw exception1;
	}

	private void exportPeer(LinkedList rep_peers, TRTrackerServerSimplePeer peer, boolean send_peer_ids, byte compact_mode, byte crypto_level, DHTNetworkPosition network_position)
	{
		Map rep_peer = new HashMap(3);
		if (send_peer_ids)
			rep_peer.put("peer id", peer.getPeerId().getHash());
		if (compact_mode != 0)
		{
			byte peer_bytes[] = peer.getIPAddressBytes();
			if (peer_bytes == null)
				return;
			rep_peer.put("ip", peer_bytes);
			if (compact_mode >= 2)
			{
				rep_peer.put("azver", new Long(peer.getAZVer()));
				rep_peer.put("azudp", new Long(peer.getUDPPort()));
				if (peer.isSeed())
					rep_peer.put("azhttp", new Long(peer.getHTTPPort()));
				if (compact_mode >= 16)
				{
					rep_peer.put("ip", peer.getIPAsRead());
				} else
				{
					rep_peer.put("azup", new Long(peer.getUpSpeed()));
					if (peer.isBiased())
						rep_peer.put("azbiased", "");
					if (network_position != null)
					{
						DHTNetworkPosition peer_pos = peer.getNetworkPosition();
						if (peer_pos != null && network_position.getPositionType() == peer_pos.getPositionType())
							rep_peer.put("azrtt", new Long((long)peer_pos.estimateRTT(network_position)));
					}
				}
			}
		} else
		{
			rep_peer.put("ip", peer.getIPAsRead());
		}
		rep_peer.put("port", new Long(peer.getTCPPort()));
		if (crypto_level != 0)
			rep_peer.put("crypto_flag", new Long(peer.getCryptoLevel() != 2 ? 0L : 1L));
		if (peer.isBiased())
			rep_peers.addFirst(rep_peer);
		else
			rep_peers.addLast(rep_peer);
	}

	public Map exportScrapeToMap(String url_parameters, String ip_address, boolean allow_cache)
		throws TRTrackerServerException
	{
		long now;
		Map map;
		this_mon.enter();
		handleRedirects(url_parameters, ip_address, true);
		stats.addScrape();
		now = SystemTime.getCurrentTime();
		long diff = now - last_scrape_calc_time;
		if (!allow_cache || last_scrape == null || diff >= (long)TRTrackerServerImpl.getScrapeCachePeriod() || diff < 0L)
			break MISSING_BLOCK_LABEL_79;
		map = last_scrape;
		this_mon.exit();
		return map;
		Map map1;
		last_scrape = new TreeMap();
		last_scrape_calc_time = now;
		Set bp = server.getBiasedPeers();
		boolean requester_is_biased;
		if (bp == null)
			requester_is_biased = false;
		else
			requester_is_biased = bp.contains(ip_address);
		last_scrape.put("complete", new Long(getSeedCountForScrape(requester_is_biased)));
		last_scrape.put("incomplete", new Long(getLeecherCount()));
		last_scrape.put("downloaded", new Long(stats.getCompletedCount()));
		map1 = last_scrape;
		this_mon.exit();
		return map1;
		Exception exception;
		exception;
		this_mon.exit();
		throw exception;
	}

	protected void checkTimeouts()
	{
		long now;
		int new_bad_NAT_count;
		int new_seed_count;
		this_mon.enter();
		now = SystemTime.getCurrentTime();
		new_bad_NAT_count = 0;
		new_seed_count = 0;
		peer_list_compaction_suspended = true;
		for (int i = 0; i < peer_list.size(); i++)
		{
			TRTrackerServerPeerImpl peer = (TRTrackerServerPeerImpl)peer_list.get(i);
			if (peer == null)
				continue;
			if (now > peer.getTimeout())
			{
				removePeer(peer, i, 5, null);
				continue;
			}
			if (peer.isSeed())
				new_seed_count++;
			if (peer.isNATStatusBad())
				new_bad_NAT_count++;
		}

		peer_list_compaction_suspended = false;
		break MISSING_BLOCK_LABEL_131;
		Exception exception;
		exception;
		peer_list_compaction_suspended = false;
		throw exception;
		bad_NAT_count = new_bad_NAT_count;
		seed_count = new_seed_count;
		if (removed_count > 1000)
		{
			removed_count = 0;
			checkForPeerListCompaction(true);
			HashMap new_peer_map = new HashMap(peer_map);
			HashMap new_peer_reuse_map = new HashMap(peer_reuse_map);
			peer_map = new_peer_map;
			peer_reuse_map = new_peer_reuse_map;
		} else
		{
			checkForPeerListCompaction(false);
		}
		Iterator it = lightweight_seed_map.values().iterator();
		do
		{
			if (!it.hasNext())
				break;
			lightweightSeed lws = (lightweightSeed)it.next();
			if (now > lws.getTimeout())
				it.remove();
		} while (true);
		this_mon.exit();
		break MISSING_BLOCK_LABEL_288;
		Exception exception1;
		exception1;
		this_mon.exit();
		throw exception1;
	}

	protected void checkForPeerListCompaction(boolean force)
	{
		if (peer_list_hole_count > 0 && !peer_list_compaction_suspended && (force || peer_list_hole_count > peer_map.size() / 10))
		{
			ArrayList new_peer_list = new ArrayList(peer_list.size() - peer_list_hole_count / 2);
			int holes_found = 0;
			for (int i = 0; i < peer_list.size(); i++)
			{
				Object obj = peer_list.get(i);
				if (obj == null)
					holes_found++;
				else
					new_peer_list.add(obj);
			}

			if (holes_found != peer_list_hole_count)
				Debug.out("TRTrackerTorrent:compactHoles: count mismatch");
			peer_list = new_peer_list;
			peer_list_hole_count = 0;
		}
	}

	protected void updateXferStats(int bytes_in, int bytes_out)
	{
		stats.addXferStats(bytes_in, bytes_out);
	}

	public TRTrackerServerTorrentStats getStats()
	{
		return stats;
	}

	protected int getPeerCount()
	{
		return peer_map.size() + lightweight_seed_map.size();
	}

	protected int getSeedCount()
	{
		if (seed_count < 0)
			Debug.out("seed count negative");
		return seed_count + lightweight_seed_map.size();
	}

	protected int getSeedCountForScrape(boolean requester_is_biased)
	{
		int seeds = getSeedCount();
		if (biased_peers != null && !requester_is_biased)
		{
			int bpc = 0;
			Iterator it = biased_peers.iterator();
			do
			{
				if (!it.hasNext())
					break;
				TRTrackerServerPeerImpl bp = (TRTrackerServerPeerImpl)it.next();
				if (bp.isSeed())
				{
					seeds--;
					bpc++;
				}
			} while (true);
			if (seeds < 0)
				seeds = 0;
			if (bpc > 0)
				seeds++;
		}
		int queued = getQueuedCount();
		if (queued > 0)
			seeds++;
		return seeds;
	}

	protected int getLeecherCount()
	{
		int res = peer_map.size() - seed_count;
		return res >= 0 ? res : 0;
	}

	public TRTrackerServerPeer[] getPeers()
	{
		TRTrackerServerPeer atrtrackerserverpeer[];
		this_mon.enter();
		TRTrackerServerPeer res[] = new TRTrackerServerPeer[peer_map.size()];
		peer_map.values().toArray(res);
		atrtrackerserverpeer = res;
		this_mon.exit();
		return atrtrackerserverpeer;
		Exception exception;
		exception;
		this_mon.exit();
		throw exception;
	}

	protected int getQueuedCount()
	{
		List l = queued_peers;
		if (l == null)
			return 0;
		else
			return l.size();
	}

	public TRTrackerServerPeerBase[] getQueuedPeers()
	{
		TRTrackerServerPeerBase atrtrackerserverpeerbase[];
		this_mon.enter();
		if (queued_peers != null)
			break MISSING_BLOCK_LABEL_28;
		atrtrackerserverpeerbase = new TRTrackerServerPeerBase[0];
		this_mon.exit();
		return atrtrackerserverpeerbase;
		TRTrackerServerPeerBase atrtrackerserverpeerbase1[];
		TRTrackerServerPeerBase res[] = new TRTrackerServerPeerBase[queued_peers.size()];
		queued_peers.toArray(res);
		atrtrackerserverpeerbase1 = res;
		this_mon.exit();
		return atrtrackerserverpeerbase1;
		Exception exception;
		exception;
		this_mon.exit();
		throw exception;
	}

	public HashWrapper getHash()
	{
		return hash;
	}

	public void addExplicitBiasedPeer(String ip, int port)
	{
		byte bytes[];
		bytes = HostNameToIPResolver.hostAddressToBytes(ip);
		if (bytes == null)
			break MISSING_BLOCK_LABEL_89;
		this_mon.enter();
		if (explicit_manual_biased_peers == null)
			explicit_manual_biased_peers = new ArrayList();
		explicit_manual_biased_peers.add(((Object) (new Object[] {
			ip, bytes, new Integer(port)
		})));
		this_mon.exit();
		break MISSING_BLOCK_LABEL_89;
		Exception exception;
		exception;
		this_mon.exit();
		throw exception;
	}

	public void setRedirects(URL urls[])
	{
		this_mon.enter();
		redirects = urls;
		this_mon.exit();
		break MISSING_BLOCK_LABEL_32;
		Exception exception;
		exception;
		this_mon.exit();
		throw exception;
	}

	public URL[] getRedirects()
	{
		return redirects;
	}

	protected void handleRedirects(String url_parameters, String real_ip_address, boolean scrape)
		throws TRTrackerServerException
	{
		if (redirects != null)
		{
			if (url_parameters.indexOf("permredirect") != -1)
			{
				Debug.out("redirect recursion");
				throw new TRTrackerServerException("redirection recursion not supported");
			}
			URL redirect = redirects[real_ip_address.hashCode() % redirects.length];
			Map headers = new HashMap();
			String redirect_str = redirect.toString();
			if (scrape)
			{
				int pos = redirect_str.indexOf("/announce");
				if (pos == -1)
					return;
				redirect_str = (new StringBuilder()).append(redirect_str.substring(0, pos)).append("/scrape").append(redirect_str.substring(pos + 9)).toString();
			}
			if (redirect_str.indexOf('?') == -1)
				redirect_str = (new StringBuilder()).append(redirect_str).append("?").toString();
			else
				redirect_str = (new StringBuilder()).append(redirect_str).append("&").toString();
			redirect_str = (new StringBuilder()).append(redirect_str).append("permredirect=1").toString();
			if (url_parameters.length() > 0)
				redirect_str = (new StringBuilder()).append(redirect_str).append("&").append(url_parameters).toString();
			System.out.println((new StringBuilder()).append("redirect -> ").append(redirect_str).toString());
			headers.put("Location", redirect_str);
			throw new TRTrackerServerException(301, "Moved Permanently", headers);
		} else
		{
			return;
		}
	}

	public void addListener(TRTrackerServerTorrentListener l)
	{
		listeners.add(l);
		if (deleted)
			l.deleted(this);
	}

	public void removeListener(TRTrackerServerTorrentListener l)
	{
		listeners.remove(l);
	}

	protected void peerEvent(TRTrackerServerPeer peer, int event, String url_parameters)
		throws TRTrackerServerException
	{
		if (peer_listeners != null)
		{
			for (int i = 0; i < peer_listeners.size(); i++)
				try
				{
					((TRTrackerServerTorrentPeerListener)peer_listeners.get(i)).eventOccurred(this, peer, event, url_parameters);
				}
				catch (TRTrackerServerException e)
				{
					throw e;
				}
				catch (Throwable e)
				{
					Debug.printStackTrace(e);
				}

		}
	}

	public void addPeerListener(TRTrackerServerTorrentPeerListener l)
	{
		if (peer_listeners == null)
			peer_listeners = new ArrayList();
		peer_listeners.add(l);
	}

	public void removePeerListener(TRTrackerServerTorrentPeerListener l)
	{
		if (peer_listeners != null)
			peer_listeners.remove(l);
	}

	public void disableCaching()
	{
		caching_enabled = false;
	}

	public boolean isCachingEnabled()
	{
		return caching_enabled;
	}

	public int getBadNATPeerCount()
	{
		return bad_NAT_count;
	}

	protected void delete()
	{
		deleted = true;
		for (int i = 0; i < listeners.size(); i++)
			((TRTrackerServerTorrentListener)listeners.get(i)).deleted(this);

	}

	public String getString()
	{
		String redirect;
		if (redirects == null)
		{
			redirect = "none";
		} else
		{
			redirect = "";
			for (int i = 0; i < redirects.length; i++)
				redirect = (new StringBuilder()).append(redirect).append(i != 0 ? "," : "").append(redirects[i]).toString();

		}
		return (new StringBuilder()).append("seeds=").append(getSeedCount()).append(",leechers=").append(getLeecherCount()).append(", redirect=").append(redirect).toString();
	}

	static 
	{
		LOGID = LogIDs.TRACKER;
	}
}