trtrackerservertorrentimpl.java

java 文件下载器。可自定义

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space 
// Source File Name:   TRTrackerServerTorrentImpl.java

package org.gudy.azureus2.core3.tracker.server.impl;

import com.aelitis.azureus.core.dht.netcoords.DHTNetworkPosition;
import java.io.PrintStream;
import java.io.UnsupportedEncodingException;
import java.net.*;
import java.util.*;
import org.gudy.azureus2.core3.logging.*;
import org.gudy.azureus2.core3.tracker.server.*;
import org.gudy.azureus2.core3.util.*;

// Referenced classes of package org.gudy.azureus2.core3.tracker.server.impl:
//			TRTrackerServerImpl, TRTrackerServerNATChecker, TRTrackerServerPeerImpl, TRTrackerServerSimplePeer, 
//			TRTrackerServerTorrentStatsImpl

public class TRTrackerServerTorrentImpl
	implements TRTrackerServerTorrent
{
	protected static class QueuedPeer
		implements TRTrackerServerPeerBase
	{

		private static final byte FLAG_SEED = 1;
		private static final byte FLAG_BIASED = 2;
		private short tcp_port;
		private short udp_port;
		private short http_port;
		private byte ip[];
		private byte crypto_level;
		private byte az_ver;
		private int create_time_secs;
		private int timeout_secs;
		private byte flags;

		protected boolean sameAs(TRTrackerServerPeerImpl peer)
		{
			return tcp_port == peer.getTCPPort() && Arrays.equals(ip, peer.getIPAsRead()) && isIPOverride() == peer.isIPOverride();
		}

		protected boolean sameAs(QueuedPeer other)
		{
			return tcp_port == other.tcp_port && Arrays.equals(ip, other.ip);
		}

		protected byte[] getIPAsRead()
		{
			return ip;
		}

		public String getIP()
		{
			return new String(ip, "ISO-8859-1");
			UnsupportedEncodingException e;
			e;
			return new String(ip);
		}

		protected boolean isSeed()
		{
			return getFlag((byte)1);
		}

		protected void setBiased(boolean _biased)
		{
			setFlag((byte)2, _biased);
		}

		protected boolean isBiased()
		{
			return getFlag((byte)2);
		}

		protected boolean isIPOverride()
		{
			return false;
		}

		protected void setFlag(byte flag, boolean value)
		{
			if (value)
				flags |= flag;
			else
				flags &= ~flag;
		}

		protected boolean getFlag(byte flag)
		{
			return (flags & flag) != 0;
		}

		protected byte[] getIPAddressBytes()
		{
			return HostNameToIPResolver.hostAddressToBytes(new String(ip, "ISO-8859-1"));
			UnsupportedEncodingException e;
			e;
			Debug.printStackTrace(e);
			return null;
		}

		public int getTCPPort()
		{
			return tcp_port & 0xffff;
		}

		protected int getUDPPort()
		{
			return udp_port & 0xffff;
		}

		protected int getHTTPPort()
		{
			return http_port & 0xffff;
		}

		protected byte getCryptoLevel()
		{
			return crypto_level;
		}

		protected byte getAZVer()
		{
			return az_ver;
		}

		protected int getCreateTime()
		{
			return create_time_secs;
		}

		protected boolean isTimedOut(long now_millis)
		{
			int now_secs = (int)(now_millis / 1000L);
			if (now_secs < create_time_secs)
				create_time_secs = now_secs;
			return create_time_secs + timeout_secs < now_secs;
		}

		public int getSecsToLive()
		{
			int now_secs = (int)(SystemTime.getCurrentTime() / 1000L);
			if (now_secs < create_time_secs)
				create_time_secs = now_secs;
			return (create_time_secs + timeout_secs) - now_secs;
		}

		protected String getString()
		{
			return (new StringBuilder()).append(new String(ip)).append(":").append(getTCPPort()).append("/").append(getUDPPort()).append("/").append(getCryptoLevel()).toString();
		}

		protected QueuedPeer(String _ip_str, int _tcp_port, int _udp_port, int _http_port, byte _crypto_level, byte _az_ver, int _timeout_secs, 
				boolean _seed, boolean _biased)
		{
			try
			{
				ip = _ip_str.getBytes("ISO-8859-1");
			}
			catch (UnsupportedEncodingException e)
			{
				Debug.printStackTrace(e);
			}
			tcp_port = (short)_tcp_port;
			udp_port = (short)_udp_port;
			http_port = (short)_http_port;
			crypto_level = _crypto_level;
			az_ver = _az_ver;
			setFlag((byte)1, _seed);
			setFlag((byte)2, _biased);
			create_time_secs = (int)(SystemTime.getCurrentTime() / 1000L);
			timeout_secs = _timeout_secs * 3;
		}
	}

	static class announceCacheEntry
	{

		protected Map data;
		protected boolean send_peer_ids;
		protected byte compact_mode;
		protected long time;

		protected boolean getSendPeerIds()
		{
			return send_peer_ids;
		}

		protected byte getCompactMode()
		{
			return compact_mode;
		}

		protected long getTime()
		{
			return time;
		}

		protected Map getData()
		{
			return data;
		}

		protected announceCacheEntry(Map _data, boolean _send_peer_ids, byte _compact_mode)
		{
			data = _data;
			send_peer_ids = _send_peer_ids;
			compact_mode = _compact_mode;
			time = SystemTime.getCurrentTime();
		}
	}

	protected static class lightweightSeed
	{

		long timeout;
		long last_contact_time;
		long uploaded;
		byte nat_status;

		protected long getTimeout()
		{
			return timeout;
		}

		protected long getLastContactTime()
		{
			return last_contact_time;
		}

		protected long getUploaded()
		{
			return uploaded;
		}

		protected byte getNATStatus()
		{
			return nat_status;
		}

		protected lightweightSeed(long _now, long _timeout, long _uploaded, byte _nat_status)
		{
			last_contact_time = _now;
			timeout = _timeout;
			uploaded = _uploaded;
			nat_status = _nat_status;
		}
	}

	protected class temporaryBiasedSeed
		implements TRTrackerServerSimplePeer
	{

		private String ip;
		private int tcp_port;
		private HashWrapper peer_id;
		final TRTrackerServerTorrentImpl this$0;

		public byte[] getIPAsRead()
		{
			return ip.getBytes("ISO-8859-1");
			Throwable e;
			e;
			return ip.getBytes();
		}

		public byte[] getIPAddressBytes()
		{
			return InetAddress.getByName(ip).getAddress();
			Throwable e;
			e;
			return null;
		}

		public HashWrapper getPeerId()
		{
			return peer_id;
		}

		public int getTCPPort()
		{
			return tcp_port;
		}

		public int getUDPPort()
		{
			return 0;
		}

		public int getHTTPPort()
		{
			return 0;
		}

		public boolean isSeed()
		{
			return true;
		}

		public boolean isBiased()
		{
			return true;
		}

		public byte getCryptoLevel()
		{
			return 0;
		}

		public byte getAZVer()
		{
			return 0;
		}

		public int getUpSpeed()
		{
			return 0;
		}

		public DHTNetworkPosition getNetworkPosition()
		{
			return null;
		}

		protected temporaryBiasedSeed(String _ip, int _tcp_port)
		{
			this$0 = TRTrackerServerTorrentImpl.this;
			super();
			ip = _ip;
			tcp_port = _tcp_port;
			peer_id = new HashWrapper(RandomUtils.nextHash());
		}
	}


	private static final LogIDs LOGID;
	public static final int MIN_CACHE_ENTRY_SIZE = 10;
	public static final int MAX_UPLOAD_BYTES_PER_SEC = 0x300000;
	public static final int MAX_DOWNLOAD_BYTES_PER_SEC = 0x300000;
	public static final boolean USE_LIGHTWEIGHT_SEEDS = true;
	public static final int MAX_IP_OVERRIDE_PEERS = 64;
	public static final byte COMPACT_MODE_NONE = 0;
	public static final byte COMPACT_MODE_NORMAL = 1;
	public static final byte COMPACT_MODE_AZ = 2;
	public static final byte COMPACT_MODE_AZ_2 = 3;
	public static final byte COMPACT_MODE_XML = 16;
	private static final int QUEUED_PEERS_MAX_SWARM_SIZE = 32;
	private static final int QUEUED_PEERS_MAX = 32;
	private static final int QUEUED_PEERS_ADD_MAX = 3;
	private TRTrackerServerImpl server;
	private HashWrapper hash;
	private Map peer_map;
	private Map peer_reuse_map;
	private List peer_list;
	private int peer_list_hole_count;
	private boolean peer_list_compaction_suspended;
	private List biased_peers;
	private int min_biased_peers;
	private Map lightweight_seed_map;
	private int seed_count;
	private int removed_count;
	private int ip_override_count;
	private int bad_NAT_count;
	private Random random;
	private long last_scrape_calc_time;
	private Map last_scrape;
	private LinkedHashMap announce_cache;
	private TRTrackerServerTorrentStatsImpl stats;
	private List listeners;
	private List peer_listeners;
	private boolean deleted;
	private boolean enabled;
	private boolean map_size_diff_reported;
	private boolean ip_override_limit_exceeded_reported;
	private byte duplicate_peer_checker_index;
	private byte duplicate_peer_checker[];
	private URL redirects[];
	private boolean caching_enabled;
	private LinkedList queued_peers;
	protected AEMonitor this_mon;
	private List explicit_manual_biased_peers;
	private int explicit_next_peer;

	public TRTrackerServerTorrentImpl(TRTrackerServerImpl _server, HashWrapper _hash, boolean _enabled)
	{
		peer_map = new HashMap();
		peer_reuse_map = new HashMap();
		peer_list = new ArrayList();
		biased_peers = null;
		min_biased_peers = 0;
		lightweight_seed_map = new HashMap();
		random = new Random(SystemTime.getCurrentTime());
		announce_cache = new LinkedHashMap();
		listeners = new ArrayList();
		duplicate_peer_checker_index = 0;
		duplicate_peer_checker = new byte[0];
		caching_enabled = true;
		this_mon = new AEMonitor("TRTrackerServerTorrent");
		server = _server;
		hash = _hash;
		enabled = _enabled;
		stats = new TRTrackerServerTorrentStatsImpl(this);
	}

	public void setEnabled(boolean _enabled)
	{
		enabled = _enabled;
	}

	public boolean isEnabled()
	{
		return enabled;
	}

	public void setMinBiasedPeers(int num)
	{
		min_biased_peers = num;
	}

	public void importPeers(List peers)
	{
		this_mon.enter();
		if (peer_map.size() <= 0)
			break MISSING_BLOCK_LABEL_35;
		System.out.println("TRTrackerServerTorrent: ignoring peer import as torrent already active");
		this_mon.exit();
		return;
		for (int i = 0; i < peers.size(); i++)
		{
			TRTrackerServerPeerImpl peer = TRTrackerServerPeerImpl.importPeer((Map)peers.get(i));
			if (peer == null)
				continue;
			try
			{
				String reuse_key = (new StringBuilder()).append(new String(peer.getIPAsRead(), "ISO-8859-1")).append(":").append(peer.getTCPPort()).toString();
				peer_map.put(peer.getPeerId(), peer);
				peer_list.add(peer);
				peer_reuse_map.put(reuse_key, peer);
				if (peer.isSeed())
					seed_count++;
				if (!peer.isBiased())
					continue;
				if (biased_peers == null)
					biased_peers = new ArrayList();
				biased_peers.add(peer);
			}
			catch (Throwable e) { }
		}

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

	public TRTrackerServerPeerImpl peerContact(String url_parameters, String event, HashWrapper peer_id, int tcp_port, int udp_port, int http_port, byte crypto_level, 
			byte az_ver, String original_address, String ip_address, boolean ip_override, boolean loopback, String tracker_key, long uploaded, long downloaded, long left, long interval_requested, 
			int up_speed, DHTNetworkPosition network_position)
		throws TRTrackerServerException
	{
label0:
		{
			if (!enabled)
				throw new TRTrackerServerException("Torrent temporarily disabled");
			if (!HostNameToIPResolver.isNonDNSName(ip_address))
				try
				{
					ip_address = HostNameToIPResolver.syncResolve(ip_address).getHostAddress();
				}
				catch (UnknownHostException e) { }
			TRTrackerServerException deferred_failure = null;
			int event_type;
			long now;
			int tracker_key_hash_code;
			TRTrackerServerPeerImpl peer;
			boolean new_peer;
			boolean peer_already_removed;
			boolean already_completed;
			long last_contact_time;
			long ul_diff;
			long dl_diff;
			long le_diff;
			byte ip_address_bytes[];
			String reuse_key;
			int existing_tracker_key_hash_code;
			long new_timeout;
			byte last_NAT_status;
			Set biased_peer_set;
			byte old_ip[];
			int old_port;
			long elapsed_time;
			int seed_limit;
			TRTrackerServerPeerImpl trtrackerserverpeerimpl;
			Set biased_peer_set;
			String old_key;
			int seed_retention;
			boolean biased;
			String new_key;
			long ul_rate;
			int to_remove;
			Iterator it;
			TRTrackerServerPeerImpl old_peer;
			int bad_nat_loop;
			QueuedPeer qp;
			long dl_rate;
			int i;
			TRTrackerServerPeerImpl this_peer;
			boolean was_seed;