trtrackerserverpeerimpl.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:   TRTrackerServerPeerImpl.java

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

import com.aelitis.azureus.core.dht.netcoords.DHTNetworkPosition;
import java.net.InetAddress;
import java.util.*;
import org.gudy.azureus2.core3.tracker.server.TRTrackerServerPeer;
import org.gudy.azureus2.core3.util.*;

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

public class TRTrackerServerPeerImpl
	implements TRTrackerServerPeer, TRTrackerServerSimplePeer, HostNameToIPResolverListener, TRTrackerServerNatCheckerListener
{

	private HashWrapper peer_id;
	private int key_hash_code;
	private byte ip[];
	private boolean ip_override;
	private short tcp_port;
	private short udp_port;
	private short http_port;
	private byte crypto_level;
	private byte az_ver;
	private String ip_str;
	private byte ip_bytes[];
	private byte NAT_status;
	private long timeout;
	private long uploaded;
	private long downloaded;
	private long amount_left;
	private long last_contact_time;
	private boolean download_completed;
	private boolean biased;
	private short up_speed;
	private DHTNetworkPosition network_position;
	private Object user_data;

	protected TRTrackerServerPeerImpl(HashWrapper _peer_id, int _key_hash_code, byte _ip[], boolean _ip_override, int _tcp_port, int _udp_port, int _http_port, 
			byte _crypto_level, byte _az_ver, long _last_contact_time, boolean _download_completed, byte _last_nat_status, int _up_speed, 
			DHTNetworkPosition _network_position)
	{
		NAT_status = 0;
		peer_id = _peer_id;
		key_hash_code = _key_hash_code;
		ip = _ip;
		ip_override = _ip_override;
		tcp_port = (short)_tcp_port;
		udp_port = (short)_udp_port;
		http_port = (short)_http_port;
		crypto_level = _crypto_level;
		az_ver = _az_ver;
		last_contact_time = _last_contact_time;
		download_completed = _download_completed;
		NAT_status = _last_nat_status;
		up_speed = _up_speed <= 32767 ? (short)_up_speed : 32767;
		network_position = _network_position;
		resolveAndCheckNAT();
	}

	protected TRTrackerServerPeerImpl(HashWrapper _peer_id, int _key_hash_code, byte _ip[], boolean _ip_override, short _tcp_port, short _udp_port, short _http_port, 
			byte _crypto_level, byte _az_ver, String _ip_str, byte _ip_bytes[], byte _NAT_status, long _timeout, 
			long _uploaded, long _downloaded, long _amount_left, long _last_contact_time, boolean _download_completed, boolean _biased, short _up_speed)
	{
		NAT_status = 0;
		peer_id = _peer_id;
		key_hash_code = _key_hash_code;
		ip = _ip;
		ip_override = _ip_override;
		tcp_port = _tcp_port;
		udp_port = _udp_port;
		http_port = _http_port;
		crypto_level = _crypto_level;
		az_ver = _az_ver;
		ip_str = _ip_str;
		ip_bytes = _ip_bytes;
		NAT_status = _NAT_status;
		timeout = _timeout;
		uploaded = _uploaded;
		downloaded = _downloaded;
		amount_left = _amount_left;
		last_contact_time = _last_contact_time;
		download_completed = _download_completed;
		biased = _biased;
		up_speed = _up_speed;
	}

	protected boolean update(byte _ip[], int _port, int _udp_port, int _http_port, byte _crypto_level, byte _az_ver, int _up_speed, 
			DHTNetworkPosition _network_position)
	{
		udp_port = (short)_udp_port;
		http_port = (short)_http_port;
		crypto_level = _crypto_level;
		az_ver = _az_ver;
		up_speed = _up_speed <= 32767 ? (short)_up_speed : 32767;
		network_position = _network_position;
		boolean res = false;
		if (_port != getTCPPort())
		{
			tcp_port = (short)_port;
			res = true;
		}
		if (!Arrays.equals(_ip, ip))
		{
			ip = _ip;
			res = true;
		}
		if (res)
			resolveAndCheckNAT();
		return res;
	}

	public void NATCheckComplete(boolean ok)
	{
		if (ok)
			NAT_status = 3;
		else
			NAT_status = 4;
	}

	protected void setNATStatus(byte status)
	{
		NAT_status = status;
	}

	public byte getNATStatus()
	{
		return NAT_status;
	}

	protected boolean isNATStatusBad()
	{
		return NAT_status == 4 || NAT_status == 5;
	}

	protected void resolveAndCheckNAT()
	{
		ip_str = new String(ip);
		ip_bytes = null;
		HostNameToIPResolver.addResolverRequest(ip_str, this);
		if (tcp_port == 0)
			NAT_status = 5;
		else
		if (NAT_status == 0)
		{
			NAT_status = 2;
			if (!TRTrackerServerNATChecker.getSingleton().addNATCheckRequest(ip_str, getTCPPort(), this))
				NAT_status = 1;
		}
	}

	public void hostNameResolutionComplete(InetAddress address)
	{
		if (address != null)
		{
			ip_str = address.getHostAddress();
			ip_bytes = address.getAddress();
		}
	}

	protected long getLastContactTime()
	{
		return last_contact_time;
	}

	protected boolean getDownloadCompleted()
	{
		return download_completed;
	}

	protected void setDownloadCompleted()
	{
		download_completed = true;
	}

	public boolean isBiased()
	{
		return biased;
	}

	public void setBiased(boolean _biased)
	{
		biased = _biased;
	}

	public HashWrapper getPeerId()
	{
		return peer_id;
	}

	public byte[] getPeerID()
	{
		return peer_id.getBytes();
	}

	protected int getKeyHashCode()
	{
		return key_hash_code;
	}

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

	public String getIPRaw()
	{
		return new String(ip);
	}

	public String getIP()
	{
		return ip_str;
	}

	protected boolean isIPOverride()
	{
		return ip_override;
	}

	public byte[] getIPAddressBytes()
	{
		return ip_bytes;
	}

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

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

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

	public byte getCryptoLevel()
	{
		return crypto_level;
	}

	public byte getAZVer()
	{
		return az_ver;
	}

	public int getUpSpeed()
	{
		return up_speed & 0xffff;
	}

	public DHTNetworkPosition getNetworkPosition()
	{
		return network_position;
	}

	protected void setTimeout(long _now, long _timeout)
	{
		last_contact_time = _now;
		timeout = _timeout;
	}

	protected long getTimeout()
	{
		return timeout;
	}

	public int getSecsToLive()
	{
		return (int)((timeout - SystemTime.getCurrentTime()) / 1000L);
	}

	protected void setStats(long _uploaded, long _downloaded, long _amount_left)
	{
		uploaded = _uploaded;
		downloaded = _downloaded;
		amount_left = _amount_left;
	}

	public long getUploaded()
	{
		return uploaded;
	}

	public long getDownloaded()
	{
		return downloaded;
	}

	public long getAmountLeft()
	{
		return amount_left;
	}

	public boolean isSeed()
	{
		return amount_left == 0L;
	}

	public void setUserData(Object key, Object data)
	{
		if (user_data == null)
			user_data = ((Object) (new Object[] {
				key, data
			}));
		else
		if (user_data instanceof Object[])
		{
			Object x[] = (Object[])(Object[])user_data;
			if (x[0] == key)
			{
				x[1] = data;
			} else
			{
				HashMap map = new HashMap();
				user_data = map;
				map.put(x[0], x[1]);
				map.put(key, data);
			}
		} else
		{
			((Map)user_data).put(key, data);
		}
	}

	public Object getUserData(Object key)
	{
		if (user_data == null)
			return null;
		if (user_data instanceof Object[])
		{
			Object x[] = (Object[])(Object[])user_data;
			if (x[0] == key)
				return x[1];
			else
				return null;
		} else
		{
			return ((Map)user_data).get(key);
		}
	}

	public Map export()
	{
		Map map = new HashMap();
		map.put("peer_id", peer_id.getBytes());
		map.put("key_hash_code", new Long(key_hash_code));
		map.put("ip", ip);
		map.put("ip_override", new Long(ip_override ? 1L : 0L));
		map.put("tcp_port", new Long(tcp_port));
		map.put("udp_port", new Long(udp_port));
		map.put("http_port", new Long(http_port));
		map.put("crypto_level", new Long(crypto_level));
		map.put("az_ver", new Long(az_ver));
		map.put("ip_str", ip_str);
		if (ip_bytes != null)
			map.put("ip_bytes", ip_bytes);
		map.put("NAT_status", new Long(NAT_status));
		map.put("timeout", new Long(timeout));
		map.put("uploaded", new Long(uploaded));
		map.put("downloaded", new Long(downloaded));
		map.put("amount_left", new Long(amount_left));
		map.put("last_contact_time", new Long(last_contact_time));
		map.put("download_completed", new Long(download_completed ? 1L : 0L));
		map.put("biased", new Long(biased ? 1L : 0L));
		map.put("up_speed", new Long(up_speed));
		return map;
	}

	public static TRTrackerServerPeerImpl importPeer(Map map)
	{
		HashWrapper peer_id;
		int key_hash_code;
		byte ip[];
		boolean ip_override;
		short tcp_port;
		short udp_port;
		short http_port;
		byte crypto_level;
		byte az_ver;
		String ip_str;
		byte ip_bytes[];
		byte NAT_status;
		long timeout;
		long uploaded;
		long downloaded;
		long amount_left;
		long last_contact_time;
		boolean download_completed;
		boolean biased;
		short up_speed;
		peer_id = new HashWrapper((byte[])(byte[])map.get("peer_id"));
		key_hash_code = ((Long)map.get("key_hash_code")).intValue();
		ip = (byte[])(byte[])map.get("ip");
		ip_override = ((Long)map.get("ip_override")).intValue() == 1;
		tcp_port = ((Long)map.get("tcp_port")).shortValue();
		udp_port = ((Long)map.get("udp_port")).shortValue();
		http_port = ((Long)map.get("http_port")).shortValue();
		crypto_level = ((Long)map.get("crypto_level")).byteValue();
		az_ver = ((Long)map.get("az_ver")).byteValue();
		ip_str = new String((byte[])(byte[])map.get("ip_str"));
		ip_bytes = (byte[])(byte[])map.get("ip_bytes");
		NAT_status = ((Long)map.get("NAT_status")).byteValue();
		timeout = ((Long)map.get("timeout")).longValue();
		uploaded = ((Long)map.get("uploaded")).longValue();
		downloaded = ((Long)map.get("downloaded")).longValue();
		amount_left = ((Long)map.get("amount_left")).longValue();
		last_contact_time = ((Long)map.get("last_contact_time")).longValue();
		download_completed = ((Long)map.get("download_completed")).intValue() == 1;
		biased = ((Long)map.get("biased")).intValue() == 1;
		up_speed = ((Long)map.get("up_speed")).shortValue();
		return new TRTrackerServerPeerImpl(peer_id, key_hash_code, ip, ip_override, tcp_port, udp_port, http_port, crypto_level, az_ver, ip_str, ip_bytes, NAT_status, timeout, uploaded, downloaded, amount_left, last_contact_time, download_completed, biased, up_speed);
		Throwable e;
		e;
		return null;
	}

	protected String getString()
	{
		return (new StringBuilder()).append(new String(ip)).append(":").append(getTCPPort()).append("(").append(new String(peer_id.getHash())).append(")").toString();
	}
}