protected void report(String resource_key, String additional_text) {
if (progress_listeners.size() > 0) {
String prefix = MessageText.getString(resource_key);
for (int i = 0; i < progress_listeners.size(); i++) {
((TOTorrentProgressListener) progress_listeners.get(i))
.reportCurrentTask(prefix + (additional_text == null ? "" : additional_text));
}
}
}
public boolean verifyParameter(String parameter, String value) {
List verifiers = ConfigurationDefaults.getInstance().getVerifiers(parameter);
if (verifiers != null) {
try {
for (int i = 0; i < verifiers.size(); i++) {
ParameterVerifier verifier = (ParameterVerifier) verifiers.get(i);
if (verifier != null) {
try {
if (!verifier.verify(parameter, value)) {
return (false);
}
} catch (Throwable e) {
Debug.printStackTrace(e);
}
}
}
} catch (Throwable e) {
// we're not synchronized so possible but unlikely error here
Debug.printStackTrace(e);
}
}
return (true);
}
private void doReadAheadLoads() {
List to_submit = null;
try {
lock_mon.enter();
while (loading_messages.size() + queued_messages.size() < request_read_ahead
&& !requests.isEmpty()
&& !destroyed) {
DiskManagerReadRequest dmr = (DiskManagerReadRequest) requests.removeFirst();
loading_messages.add(dmr);
if (to_submit == null) to_submit = new ArrayList();
to_submit.add(dmr);
}
} finally {
lock_mon.exit();
}
/*
if ( peer.getIp().equals( "64.71.5.2")){
TimeFormatter.milliTrace( "obt read_ahead: -> " + (to_submit==null?0:to_submit.size()) +
" [lo=" + loading_messages.size() + ",qm=" + queued_messages.size() + ",re=" + requests.size() + ",rl=" + request_read_ahead + "]");
}
*/
if (to_submit != null) {
for (int i = 0; i < to_submit.size(); i++) {
peer.getManager()
.getAdapter()
.enqueueReadRequest(peer, (DiskManagerReadRequest) to_submit.get(i), read_req_listener);
}
}
}
public String[] getPersistentStringListProperty(String prop) {
synchronized (persistent_properties) {
try {
List<byte[]> values = (List<byte[]>) persistent_properties.get(prop);
if (values == null) {
return (new String[0]);
}
String[] res = new String[values.size()];
int pos = 0;
for (byte[] value : values) {
res[pos++] = new String(value, "UTF-8");
}
return (res);
} catch (Throwable e) {
Debug.printStackTrace(e);
return (new String[0]);
}
}
}
private long[] getTotals(int day, long start_offset) {
if (start_offset == 0) {
return (getTotals(day));
} else {
List<Long> records = getContents().get(day + "." + start_offset);
if (records != null) {
long[] result = new long[STAT_ENTRY_COUNT];
if (records.size() == STAT_ENTRY_COUNT) {
for (int i = 0; i < STAT_ENTRY_COUNT; i++) {
result[i] = (Long) records.get(i);
}
}
return (result);
}
return (null);
}
}
public String[] getRecommendedPlugins() {
Map reply = getVersionCheckInfo(REASON_RECOMMENDED_PLUGINS, AT_EITHER);
List l = (List) reply.get("recommended_plugins");
if (l == null) {
return (new String[0]);
}
String[] res = new String[l.size()];
for (int i = 0; i < l.size(); i++) {
res[i] = new String((byte[]) l.get(i));
}
return (res);
}
public void save(String filename) {
if (propertiesMap == null) {
// nothing to save, initialisation not complete
return;
}
/**
* Note - propertiesMap isn't synchronised! We'll clone the map now, because we need to modify
* it. The BEncoding code will create a new map object (TreeMap) because it needs to be sorted,
* so we might as well do it here too.
*/
TreeMap<String, Object> properties_clone = propertiesMap.toTreeMap();
// Remove any transient parameters.
if (!this.transient_properties.isEmpty()) {
properties_clone.keySet().removeAll(this.transient_properties);
}
FileUtil.writeResilientConfigFile(filename, properties_clone);
List<COConfigurationListener> listeners_copy;
synchronized (listenerz) {
listeners_copy = new ArrayList<COConfigurationListener>(listenerz);
}
for (int i = 0; i < listeners_copy.size(); i++) {
COConfigurationListener l = (COConfigurationListener) listeners_copy.get(i);
if (l != null) {
try {
l.configurationSaved();
} catch (Throwable e) {
Debug.printStackTrace(e);
}
} else {
Debug.out("COConfigurationListener is null");
}
}
if (exported_parameters_dirty) {
exportParameters();
}
}
public void pieceHashed(int piece_number) {
for (int i = 0; i < progress_listeners.size(); i++) {
int this_progress = (int) ((piece_number * 100) / piece_count);
if (this_progress != reported_progress) {
reported_progress = this_progress;
((TOTorrentProgressListener) progress_listeners.get(i)).reportProgress(reported_progress);
}
}
}
public boolean setParameter(String parameter, StringList value) {
try {
List encoded = new ArrayList();
List l = ((StringListImpl) value).getList();
for (int i = 0; i < l.size(); i++) {
encoded.add(stringToBytes((String) l.get(i)));
}
propertiesMap.put(parameter, encoded);
notifyParameterListeners(parameter);
} catch (Exception e) {
Debug.printStackTrace(e);
return false;
}
return true;
}
protected void initialisationComplete() {
Iterator<PluginListener> it = listeners.iterator();
while (it.hasNext()) {
try {
fireInitComplete(it.next());
} catch (Throwable e) {
Debug.printStackTrace(e);
}
}
for (int i = 0; i < children.size(); i++) {
((PluginInterfaceImpl) children.get(i)).initialisationComplete();
}
}
protected void closedownComplete() {
Iterator it = listeners.iterator();
while (it.hasNext()) {
try {
((PluginListener) it.next()).closedownComplete();
} catch (Throwable e) {
Debug.printStackTrace(e);
}
}
for (int i = 0; i < children.size(); i++) {
((PluginInterfaceImpl) children.get(i)).closedownComplete();
}
}
public String[][] getDisplayProperties() {
List<String[]> dp = new ArrayList<String[]>();
getDisplayProperties(dp);
String[][] res = new String[2][dp.size()];
int pos = 0;
for (String[] entry : dp) {
res[0][pos] = entry[0];
res[1][pos] = entry[1];
pos++;
}
return (res);
}
private long[] getTotals(int day) {
List<Long> records = getContents().get(String.valueOf(day));
if (records != null) {
long[] result = new long[STAT_ENTRY_COUNT];
if (records.size() == STAT_ENTRY_COUNT) {
for (int i = 0; i < STAT_ENTRY_COUNT; i++) {
result[i] = (Long) records.get(i);
}
}
return (result);
}
return (null);
}
protected void firePluginEventSupport(PluginEvent event) {
Iterator<PluginEventListener> it = event_listeners.iterator();
while (it.hasNext()) {
try {
PluginEventListener listener = it.next();
listener.handleEvent(event);
} catch (Throwable e) {
Debug.printStackTrace(e);
}
}
for (int i = 0; i < children.size(); i++) {
((PluginInterfaceImpl) children.get(i)).firePluginEvent(event);
}
}
private TranscodeProfile[] getTranscodeProfiles(String classification) {
List<TranscodeProfile> profiles = new ArrayList<TranscodeProfile>();
DeviceManagerImpl dm = getManager();
TranscodeProvider[] providers = dm.getProviders();
for (TranscodeProvider provider : providers) {
TranscodeProfile[] ps = provider.getProfiles(classification);
if (providers.length == 1) {
return (ps);
}
profiles.addAll(Arrays.asList(ps));
}
return (profiles.toArray(new TranscodeProfile[profiles.size()]));
}
public TranscodeFileImpl[] getFiles() {
try {
synchronized (this) {
if (device_files == null) {
loadDeviceFile();
}
List<TranscodeFile> result = new ArrayList<TranscodeFile>();
Iterator<Map.Entry<String, Map<String, ?>>> it = device_files.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<String, Map<String, ?>> entry = it.next();
try {
TranscodeFileImpl tf = new TranscodeFileImpl(this, entry.getKey(), device_files);
result.add(tf);
} catch (Throwable e) {
it.remove();
log("Failed to deserialise transcode file", e);
}
}
return (result.toArray(new TranscodeFileImpl[result.size()]));
}
} catch (Throwable e) {
Debug.out(e);
return (new TranscodeFileImpl[0]);
}
}
private void releaseFile() {
if (clone) {
return;
}
try {
file_map_mon.enter();
// System.out.println( "FMFile::releaseFile:" + canonical_path + "("+ owner.getName() + ")" +
// " - " + Debug.getCompressedStackTrace());
List owners = (List) file_map.get(canonical_path);
if (owners != null) {
for (Iterator it = owners.iterator(); it.hasNext(); ) {
Object[] entry = (Object[]) it.next();
if (owner.getName().equals(((FMFileOwner) entry[0]).getName())) {
it.remove();
break;
}
}
if (owners.size() == 0) {
file_map.remove(canonical_path);
}
}
} finally {
file_map_mon.exit();
}
}
public ResourceDownloaderAlternateImpl(
ResourceDownloaderBaseImpl _parent,
ResourceDownloader[] _delegates,
int _max_to_try,
boolean _random) {
super(_parent);
delegates = _delegates;
max_to_try = _max_to_try;
random = _random;
for (int i = 0; i < delegates.length; i++) {
((ResourceDownloaderBaseImpl) delegates[i]).setParent(this);
}
if (max_to_try < 0) {
max_to_try = delegates.length;
} else {
max_to_try = Math.min(max_to_try, delegates.length);
}
if (random) {
List l = new ArrayList(Arrays.asList(delegates));
delegates = new ResourceDownloader[delegates.length];
for (int i = 0; i < delegates.length; i++) {
delegates[i] = (ResourceDownloader) l.remove((int) (Math.random() * l.size()));
}
}
}
private void write(int record_type, long[] line_stats) {
synchronized (this) {
try {
final long now = SystemTime.getCurrentTime();
final long now_mins = now / (1000 * 60);
String[] bits = utc_date_format.format(new Date(now)).split(",");
String year = bits[0];
String month = bits[1];
String day = bits[2];
String current_rel_file = year + File.separator + month + File.separator + day + ".dat";
String line;
String stats_str = "";
if (record_type == RT_SESSION_START) {
// absolute values
for (int i = 0; i < line_stats.length; i++) {
stats_str += "," + line_stats[i];
line_stats_prev[i] = 0;
}
day_cache = null;
} else {
// relative values
long[] diffs = new long[STAT_ENTRY_COUNT];
for (int i = 0; i < line_stats.length; i++) {
long diff = line_stats[i] - line_stats_prev[i];
session_total += diff;
diffs[i] = diff;
stats_str += "," + diff;
line_stats_prev[i] = line_stats[i];
stat_averages[i].update(diff);
}
if (day_cache != null) {
if (day_cache.isForDay(year, month, day)) {
day_cache.addRecord(now_mins, diffs);
}
}
}
if (record_type != RT_SESSION_STATS) {
line =
(record_type == RT_SESSION_START ? "s," : "e,")
+ VERSION
+ ","
+ now_mins
+ stats_str;
} else {
line = stats_str.substring(1);
}
if (writer == null || !writer_rel_file.equals(current_rel_file)) {
// first open of a file or file switch
if (writer != null) {
// file switch
if (record_type != RT_SESSION_START) {
writer.println(line);
}
writer.close();
if (writer.checkError()) {
writer = null;
throw (new IOException("Write faled"));
}
writer = null;
}
// no point in opening a new file just to record the session-end
if (record_type != RT_SESSION_END) {
File file = new File(stats_dir, current_rel_file);
file.getParentFile().mkdirs();
writer = new PrintWriter(new FileWriter(file, true));
writer_rel_file = current_rel_file;
if (record_type == RT_SESSION_START) {
writer.println(line);
} else {
// first entry in a new file, files always start with a session-start so they
// can be processed in isolation so reset the session data and start a new one
st_p_sent += line_stats[0];
st_d_sent += line_stats[1];
st_p_received += line_stats[2];
st_d_received += line_stats[3];
st_dht_sent += line_stats[4];
st_dht_received += line_stats[5];
ss_p_sent += line_stats[0];
ss_d_sent += line_stats[1];
ss_p_received += line_stats[2];
ss_d_received += line_stats[3];
ss_dht_sent += line_stats[4];
ss_dht_received += line_stats[5];
stats_str = "";
long[] st_stats =
new long[] {
st_p_sent, st_d_sent, st_p_received, st_d_received, st_dht_sent, st_dht_received
};
for (int i = 0; i < st_stats.length; i++) {
stats_str += "," + st_stats[i];
line_stats_prev[i] = 0;
}
line = "s," + VERSION + "," + now_mins + stats_str;
writer.println(line);
}
}
} else {
writer.println(line);
}
} catch (Throwable e) {
Debug.out("Failed to write long term stats", e);
} finally {
if (writer != null) {
if (record_type == RT_SESSION_END) {
writer.close();
}
if (writer.checkError()) {
Debug.out("Failed to write long term stats");
writer.close();
writer = null;
} else {
if (record_type == RT_SESSION_END) {
writer = null;
}
}
}
}
}
if (record_type != RT_SESSION_END) {
final List<LongTermStatsListener> to_fire = new ArrayList<LongTermStatsListener>();
for (Object[] entry : listeners) {
long diff = session_total - (Long) entry[2];
if (diff >= (Long) entry[1]) {
entry[2] = session_total;
to_fire.add((LongTermStatsListener) entry[0]);
}
}
if (to_fire.size() > 0) {
dispatcher.dispatch(
new AERunnable() {
@Override
public void runSupport() {
for (LongTermStatsListener l : to_fire) {
try {
l.updated(LongTermStatsImpl.this);
} catch (Throwable e) {
Debug.out(e);
}
}
}
});
}
}
}
private void reserveAccess(String reason) throws FMFileManagerException {
if (clone) {
return;
}
try {
file_map_mon.enter();
// System.out.println( "FMFile::reserveAccess:" + canonical_path + "("+ owner.getName() + ")"
// + " [" + (access_mode==FM_WRITE?"write":"read") + "]" + " - " +
// Debug.getCompressedStackTrace());
List owners = (List) file_map.get(canonical_path);
Object[] my_entry = null;
if (owners == null) {
Debug.out("reserveAccess fail");
throw (new FMFileManagerException(
"File '"
+ canonical_path
+ "' has not been reserved (no entries), '"
+ owner.getName()
+ "'"));
}
for (Iterator it = owners.iterator(); it.hasNext(); ) {
Object[] entry = (Object[]) it.next();
String entry_name = ((FMFileOwner) entry[0]).getName();
// System.out.println( " existing entry: " + entry_name );
if (owner.getName().equals(entry_name)) {
my_entry = entry;
}
}
if (my_entry == null) {
Debug.out("reserveAccess fail");
throw (new FMFileManagerException(
"File '"
+ canonical_path
+ "' has not been reserved (not found), '"
+ owner.getName()
+ "'"));
}
my_entry[1] = new Boolean(access_mode == FM_WRITE);
my_entry[2] = reason;
int read_access = 0;
int write_access = 0;
int write_access_lax = 0;
TOTorrentFile my_torrent_file = owner.getTorrentFile();
StringBuilder users_sb = owners.size() == 1 ? null : new StringBuilder(128);
for (Iterator it = owners.iterator(); it.hasNext(); ) {
Object[] entry = (Object[]) it.next();
FMFileOwner this_owner = (FMFileOwner) entry[0];
if (((Boolean) entry[1]).booleanValue()) {
write_access++;
TOTorrentFile this_tf = this_owner.getTorrentFile();
if (my_torrent_file != null
&& this_tf != null
&& my_torrent_file.getLength() == this_tf.getLength()) {
write_access_lax++;
}
if (users_sb != null) {
if (users_sb.length() > 0) {
users_sb.append(",");
}
users_sb.append(this_owner.getName());
users_sb.append(" [write]");
}
} else {
read_access++;
if (users_sb != null) {
if (users_sb.length() > 0) {
users_sb.append(",");
}
users_sb.append(this_owner.getName());
users_sb.append(" [read]");
}
}
}
if (write_access > 1 || (write_access == 1 && read_access > 0)) {
// relax locking if strict is disabled and torrent file is same size
if (!COConfigurationManager.getBooleanParameter("File.strict.locking")) {
if (write_access_lax == write_access) {
return;
}
}
Debug.out("reserveAccess fail");
throw (new FMFileManagerException(
"File '"
+ canonical_path
+ "' is in use by '"
+ (users_sb == null ? "eh?" : users_sb.toString())
+ "'"));
}
} finally {
file_map_mon.exit();
}
}
protected Object[] handleAnnounceAndScrape(
String client_ip_address, PRUDPPacketRequest request, int request_type) throws Exception {
if (!checkConnectionId(client_ip_address, request.getConnectionId())) {
return (null);
}
List hashbytes = new ArrayList();
HashWrapper peer_id = null;
int port = 0;
String event = null;
long uploaded = 0;
long downloaded = 0;
long left = 0;
int num_want = -1;
String key = null;
if (request_type == TRTrackerServerRequest.RT_ANNOUNCE) {
if (PRUDPPacketTracker.VERSION == 1) {
PRUDPPacketRequestAnnounce announce = (PRUDPPacketRequestAnnounce) request;
hashbytes.add(announce.getHash());
peer_id = new HashWrapper(announce.getPeerId());
port = announce.getPort();
int i_event = announce.getEvent();
switch (i_event) {
case PRUDPPacketRequestAnnounce.EV_STARTED:
{
event = "started";
break;
}
case PRUDPPacketRequestAnnounce.EV_STOPPED:
{
event = "stopped";
break;
}
case PRUDPPacketRequestAnnounce.EV_COMPLETED:
{
event = "completed";
break;
}
}
uploaded = announce.getUploaded();
downloaded = announce.getDownloaded();
left = announce.getLeft();
num_want = announce.getNumWant();
int i_ip = announce.getIPAddress();
if (i_ip != 0) {
client_ip_address = PRHelpers.intToAddress(i_ip);
}
} else {
PRUDPPacketRequestAnnounce2 announce = (PRUDPPacketRequestAnnounce2) request;
hashbytes.add(announce.getHash());
peer_id = new HashWrapper(announce.getPeerId());
port = announce.getPort();
int i_event = announce.getEvent();
switch (i_event) {
case PRUDPPacketRequestAnnounce.EV_STARTED:
{
event = "started";
break;
}
case PRUDPPacketRequestAnnounce.EV_STOPPED:
{
event = "stopped";
break;
}
case PRUDPPacketRequestAnnounce.EV_COMPLETED:
{
event = "completed";
break;
}
}
uploaded = announce.getUploaded();
downloaded = announce.getDownloaded();
left = announce.getLeft();
num_want = announce.getNumWant();
int i_ip = announce.getIPAddress();
if (i_ip != 0) {
client_ip_address = PRHelpers.intToAddress(i_ip);
}
key = "" + announce.getKey();
}
} else {
PRUDPPacketRequestScrape scrape = (PRUDPPacketRequestScrape) request;
hashbytes.addAll(scrape.getHashes());
}
Map[] root_out = new Map[1];
TRTrackerServerPeerImpl[] peer_out = new TRTrackerServerPeerImpl[1];
TRTrackerServerTorrentImpl torrent =
processTrackerRequest(
server,
"",
root_out,
peer_out,
request_type,
(byte[][]) hashbytes.toArray(new byte[0][0]),
null,
null,
peer_id,
false,
TRTrackerServerTorrentImpl.COMPACT_MODE_NONE,
key, // currently no "no_peer_id" / "compact" in the packet and anyway they aren't
// returned / key
event,
false,
port,
0,
0,
client_ip_address,
client_ip_address,
downloaded,
uploaded,
left,
num_want,
TRTrackerServerPeer.CRYPTO_NONE,
(byte) 1,
0,
null);
Map root = root_out[0];
if (request_type == TRTrackerServerRequest.RT_ANNOUNCE) {
if (PRUDPPacketTracker.VERSION == 1) {
PRUDPPacketReplyAnnounce reply = new PRUDPPacketReplyAnnounce(request.getTransactionId());
reply.setInterval(((Long) root.get("interval")).intValue());
List peers = (List) root.get("peers");
int[] addresses = new int[peers.size()];
short[] ports = new short[addresses.length];
for (int i = 0; i < addresses.length; i++) {
Map peer = (Map) peers.get(i);
addresses[i] = PRHelpers.addressToInt(new String((byte[]) peer.get("ip")));
ports[i] = (short) ((Long) peer.get("port")).shortValue();
}
reply.setPeers(addresses, ports);
return (new Object[] {reply, torrent});
} else {
PRUDPPacketReplyAnnounce2 reply = new PRUDPPacketReplyAnnounce2(request.getTransactionId());
reply.setInterval(((Long) root.get("interval")).intValue());
boolean local_scrape = client_ip_address.equals("127.0.0.1");
Map scrape_details = torrent.exportScrapeToMap("", client_ip_address, !local_scrape);
int seeders = ((Long) scrape_details.get("complete")).intValue();
int leechers = ((Long) scrape_details.get("incomplete")).intValue();
reply.setLeechersSeeders(leechers, seeders);
List peers = (List) root.get("peers");
int[] addresses = new int[peers.size()];
short[] ports = new short[addresses.length];
for (int i = 0; i < addresses.length; i++) {
Map peer = (Map) peers.get(i);
addresses[i] = PRHelpers.addressToInt(new String((byte[]) peer.get("ip")));
ports[i] = (short) ((Long) peer.get("port")).shortValue();
}
reply.setPeers(addresses, ports);
return (new Object[] {reply, torrent});
}
} else {
if (PRUDPPacketTracker.VERSION == 1) {
PRUDPPacketReplyScrape reply = new PRUDPPacketReplyScrape(request.getTransactionId());
/*
Long interval = (Long)root.get("interval");
if ( interval != null ){
reply.setInterval(interval.intValue());
}
*/
Map files = (Map) root.get("files");
byte[][] hashes = new byte[files.size()][];
int[] s_complete = new int[hashes.length];
int[] s_downloaded = new int[hashes.length];
int[] s_incomplete = new int[hashes.length];
Iterator it = files.keySet().iterator();
int pos = 0;
while (it.hasNext()) {
String hash_str = (String) it.next();
hashes[pos] = hash_str.getBytes(Constants.BYTE_ENCODING);
Map details = (Map) files.get(hash_str);
s_complete[pos] = ((Long) details.get("complete")).intValue();
s_incomplete[pos] = ((Long) details.get("incomplete")).intValue();
s_downloaded[pos] = ((Long) details.get("downloaded")).intValue();
pos++;
}
reply.setDetails(hashes, s_complete, s_downloaded, s_incomplete);
return (new Object[] {reply, torrent});
} else {
PRUDPPacketReplyScrape2 reply = new PRUDPPacketReplyScrape2(request.getTransactionId());
/*
Long interval = (Long)root.get("interval");
if ( interval != null ){
reply.setInterval(interval.intValue());
}
*/
Map files = (Map) root.get("files");
int[] s_complete = new int[files.size()];
int[] s_downloaded = new int[s_complete.length];
int[] s_incomplete = new int[s_complete.length];
Iterator it = files.keySet().iterator();
int pos = 0;
while (it.hasNext()) {
String hash_str = (String) it.next();
Map details = (Map) files.get(hash_str);
s_complete[pos] = ((Long) details.get("complete")).intValue();
s_incomplete[pos] = ((Long) details.get("incomplete")).intValue();
s_downloaded[pos] = ((Long) details.get("downloaded")).intValue();
pos++;
}
reply.setDetails(s_complete, s_downloaded, s_incomplete);
return (new Object[] {reply, torrent});
}
}
}
protected void constructFixed(File _torrent_base, long _piece_length) throws TOTorrentException {
setIgnoreList();
setCreationDate(SystemTime.getCurrentTime() / 1000);
setCreatedBy(Constants.AZUREUS_NAME + "/" + Constants.AZUREUS_VERSION);
setPieceLength(_piece_length);
report("Torrent.create.progress.piecelength", _piece_length);
piece_count = calculateNumberOfPieces(_torrent_base, _piece_length);
if (piece_count == 0) {
throw (new TOTorrentException(
"TOTorrentCreate: specified files have zero total length",
TOTorrentException.RT_ZERO_LENGTH));
}
report("Torrent.create.progress.hashing");
for (int i = 0; i < progress_listeners.size(); i++) {
((TOTorrentProgressListener) progress_listeners.get(i)).reportProgress(0);
}
boolean add_other_per_file_hashes = add_other_hashes && !getSimpleTorrent();
file_hasher =
new TOTorrentFileHasher(
add_other_hashes,
add_other_per_file_hashes,
(int) _piece_length,
progress_listeners.size() == 0 ? null : this);
if (cancelled) {
throw (new TOTorrentException(
"TOTorrentCreate: operation cancelled", TOTorrentException.RT_CANCELLED));
}
if (getSimpleTorrent()) {
long length = file_hasher.add(_torrent_base);
setFiles(
new TOTorrentFileImpl[] {
new TOTorrentFileImpl(this, 0, length, new byte[][] {getName()})
});
setPieces(file_hasher.getPieces());
} else {
Vector encoded = new Vector();
processDir(file_hasher, _torrent_base, encoded, "");
TOTorrentFileImpl[] files = new TOTorrentFileImpl[encoded.size()];
encoded.copyInto(files);
setFiles(files);
}
setPieces(file_hasher.getPieces());
if (add_other_hashes) {
byte[] sha1_digest = file_hasher.getSHA1Digest();
byte[] ed2k_digest = file_hasher.getED2KDigest();
addAdditionalInfoProperty("sha1", sha1_digest);
addAdditionalInfoProperty("ed2k", ed2k_digest);
// System.out.println( "overall:sha1 = " + ByteFormatter.nicePrint( sha1_digest, true));
// System.out.println( "overall:ed2k = " + ByteFormatter.nicePrint( ed2k_digest, true));
}
}
protected void report(String resource_key, long bytes) {
if (progress_listeners.size() > 0) {
report(resource_key, DisplayFormatters.formatByteCountToKiBEtc(bytes));
}
}
protected void processDir(TOTorrentFileHasher hasher, File dir, Vector encoded, String root)
throws TOTorrentException {
File[] dir_file_list = dir.listFiles();
if (dir_file_list == null) {
throw (new TOTorrentException(
"TOTorrentCreate: directory '"
+ dir.getAbsolutePath()
+ "' returned error when listing files in it",
TOTorrentException.RT_FILE_NOT_FOUND));
}
// sort contents so that multiple encodes of a dir always
// generate same torrent
List file_list = new ArrayList(Arrays.asList(dir_file_list));
Collections.sort(file_list);
long offset = 0;
for (int i = 0; i < file_list.size(); i++) {
File file = (File) file_list.get(i);
String file_name = file.getName();
if (!(file_name.equals(".") || file_name.equals(".."))) {
if (file.isDirectory()) {
if (root.length() > 0) {
file_name = root + File.separator + file_name;
}
processDir(hasher, file, encoded, file_name);
} else {
if (!ignoreFile(file_name)) {
if (root.length() > 0) {
file_name = root + File.separator + file_name;
}
long length = hasher.add(file);
TOTorrentFileImpl tf = new TOTorrentFileImpl(this, offset, length, file_name);
offset += length;
if (add_other_hashes) {
byte[] ed2k_digest = hasher.getPerFileED2KDigest();
byte[] sha1_digest = hasher.getPerFileSHA1Digest();
// System.out.println( "file:ed2k = " + ByteFormatter.nicePrint( ed2k_digest, true ));
// System.out.println( "file:sha1 = " + ByteFormatter.nicePrint( sha1_digest, true ));
tf.setAdditionalProperty("sha1", sha1_digest);
tf.setAdditionalProperty("ed2k", ed2k_digest);
}
encoded.addElement(tf);
}
}
}
}
}
protected long allocateConnectionId(String client_address) {
try {
random_mon.enter();
long id = random.nextLong();
Long new_key = new Long(id);
connectionData new_data = new connectionData(client_address, id);
// check for timeouts
if (new_data.getTime() - last_timeout_check > 500) {
last_timeout_check = new_data.getTime();
Iterator<Long> it = connection_id_map.keySet().iterator();
while (it.hasNext()) {
Long key = it.next();
connectionData data = connection_id_map.get(key);
if (new_data.getTime() - data.getTime() > CONNECTION_ID_LIFETIME) {
// System.out.println( "TRTrackerServerProcessorUDP: connection id timeout" );
it.remove();
List<connectionData> cds = connection_ip_map.get(client_address);
if (cds != null) {
Iterator<connectionData> it2 = cds.iterator();
while (it2.hasNext()) {
if (it2.next().getID() == key) {
it2.remove();
break;
}
}
if (cds.size() == 0) {
connection_ip_map.remove(client_address);
}
}
} else {
// insertion order into map is time based - LinkedHashMap returns keys in same order
break;
}
}
}
List<connectionData> cds = connection_ip_map.get(client_address);
if (cds == null) {
cds = new ArrayList<connectionData>();
connection_ip_map.put(client_address, cds);
}
cds.add(new_data);
if (cds.size() > 512) {
connectionData dead = cds.remove(0);
connection_id_map.remove(dead.getID());
}
connection_id_map.put(new_key, new_data);
// System.out.println( "TRTrackerServerProcessorUDP: allocated:" + id + ", connection id map
// size = " + connection_id_map.size());
return (id);
} finally {
random_mon.exit();
}
}
/**
* Construct the default version check message.
*
* @return message to send
*/
public static Map constructVersionCheckMessage(String reason) {
// only send if anonymous-check flag is not set
boolean send_info = COConfigurationManager.getBooleanParameter("Send Version Info");
Map message = new HashMap();
// always send
message.put("appid", SystemProperties.getApplicationIdentifier());
message.put("appname", SystemProperties.getApplicationName());
message.put("version", Constants.AZUREUS_VERSION);
String sub_ver = Constants.AZUREUS_SUBVER;
if (sub_ver.length() > 0) {
message.put("subver", sub_ver);
}
if (COConfigurationManager.getBooleanParameter("Beta Programme Enabled")) {
message.put("beta_prog", "true");
}
message.put("ui", COConfigurationManager.getStringParameter("ui", "unknown"));
message.put("os", Constants.OSName);
message.put("os_version", System.getProperty("os.version"));
message.put(
"os_arch", System.getProperty("os.arch")); // see http://lopica.sourceforge.net/os.html
boolean using_phe =
COConfigurationManager.getBooleanParameter("network.transport.encrypted.require");
message.put("using_phe", using_phe ? new Long(1) : new Long(0));
// swt stuff
try {
Class c = Class.forName("org.eclipse.swt.SWT");
String swt_platform =
(String) c.getMethod("getPlatform", new Class[] {}).invoke(null, new Object[] {});
message.put("swt_platform", swt_platform);
Integer swt_version =
(Integer) c.getMethod("getVersion", new Class[] {}).invoke(null, new Object[] {});
message.put("swt_version", new Long(swt_version.longValue()));
if (send_info) {
c = Class.forName("org.gudy.azureus2.ui.swt.mainwindow.MainWindow");
if (c != null) {
c.getMethod("addToVersionCheckMessage", new Class[] {Map.class})
.invoke(null, new Object[] {message});
}
}
} catch (ClassNotFoundException e) {
/* ignore */
} catch (NoClassDefFoundError er) {
/* ignore */
} catch (InvocationTargetException err) {
/* ignore */
} catch (Throwable t) {
t.printStackTrace();
}
int last_send_time = COConfigurationManager.getIntParameter("Send Version Info Last Time", -1);
int current_send_time = (int) (SystemTime.getCurrentTime() / 1000);
COConfigurationManager.setParameter("Send Version Info Last Time", current_send_time);
String id = COConfigurationManager.getStringParameter("ID", null);
if (id != null && send_info) {
message.put("id", id);
try {
byte[] id2 = CryptoManagerFactory.getSingleton().getSecureID();
message.put("id2", id2);
} catch (Throwable e) {
}
if (last_send_time != -1 && last_send_time < current_send_time) {
// time since last
message.put("tsl", new Long(current_send_time - last_send_time));
}
message.put("reason", reason);
String java_version = System.getProperty("java.version");
if (java_version == null) {
java_version = "unknown";
}
message.put("java", java_version);
String java_vendor = System.getProperty("java.vm.vendor");
if (java_vendor == null) {
java_vendor = "unknown";
}
message.put("javavendor", java_vendor);
long max_mem = Runtime.getRuntime().maxMemory() / (1024 * 1024);
message.put("javamx", new Long(max_mem));
String java_rt_name = System.getProperty("java.runtime.name");
if (java_rt_name != null) {
message.put("java_rt_name", java_rt_name);
}
String java_rt_version = System.getProperty("java.runtime.version");
if (java_rt_version != null) {
message.put("java_rt_version", java_rt_version);
}
OverallStats stats = StatsFactory.getStats();
if (stats != null) {
// long total_bytes_downloaded = stats.getDownloadedBytes();
// long total_bytes_uploaded = stats.getUploadedBytes();
long total_uptime = stats.getTotalUpTime();
// removed due to complaints about anonymous stats collection
// message.put( "total_bytes_downloaded", new Long( total_bytes_downloaded ) );
// message.put( "total_bytes_uploaded", new Long( total_bytes_uploaded ) );
message.put("total_uptime", new Long(total_uptime));
// message.put( "dlstats", stats.getDownloadStats());
}
try {
NetworkAdminASN current_asn = NetworkAdmin.getSingleton().getCurrentASN();
String as = current_asn.getAS();
message.put("ip_as", current_asn.getAS());
String asn = current_asn.getASName();
if (asn.length() > 64) {
asn = asn.substring(0, 64);
}
message.put("ip_asn", asn);
} catch (Throwable e) {
Debug.out(e);
}
// send locale, so we can determine which languages need attention
message.put("locale", Locale.getDefault().toString());
String originalLocale =
System.getProperty("user.language") + "_" + System.getProperty("user.country");
String variant = System.getProperty("user.variant");
if (variant != null && variant.length() > 0) {
originalLocale += "_" + variant;
}
message.put("orig_locale", originalLocale);
// We may want to reply differently if the user is in Beginner mode vs Advanced
message.put("user_mode", COConfigurationManager.getIntParameter("User Mode", -1));
Set<String> features = UtilitiesImpl.getFeaturesInstalled();
if (features.size() > 0) {
String str = "";
for (String f : features) {
str += (str.length() == 0 ? "" : ",") + f;
}
message.put("vzfeatures", str);
}
try {
if (AzureusCoreFactory.isCoreAvailable()) {
// installed plugin IDs
PluginInterface[] plugins =
AzureusCoreFactory.getSingleton().getPluginManager().getPluginInterfaces();
List pids = new ArrayList();
List vs_data = new ArrayList();
for (int i = 0; i < plugins.length; i++) {
PluginInterface plugin = plugins[i];
String pid = plugin.getPluginID();
String info = plugin.getPluginconfig().getPluginStringParameter("plugin.info");
// filter out built-in and core ones
if ((info != null && info.length() > 0)
|| (!pid.startsWith("<")
&& !pid.startsWith("azbp")
&& !pid.startsWith("azupdater")
&& !pid.startsWith("azplatform")
&& !pids.contains(pid))) {
if (info != null && info.length() > 0) {
if (info.length() < 256) {
pid += ":" + info;
} else {
Debug.out("Plugin '" + pid + "' reported excessive info string '" + info + "'");
}
}
pids.add(pid);
}
Map data =
plugin.getPluginconfig().getPluginMapParameter("plugin.versionserver.data", null);
if (data != null) {
Map payload = new HashMap();
byte[] data_bytes = BEncoder.encode(data);
if (data_bytes.length > 16 * 1024) {
Debug.out(
"Plugin '"
+ pid
+ "' reported excessive version server data (length="
+ data_bytes.length
+ ")");
payload.put("error", "data too long: " + data_bytes.length);
} else {
payload.put("data", data_bytes);
}
payload.put("id", pid);
payload.put("version", plugin.getPluginVersion());
vs_data.add(payload);
}
}
message.put("plugins", pids);
if (vs_data.size() > 0) {
message.put("plugin_data", vs_data);
}
}
} catch (Throwable e) {
Debug.out(e);
}
}
return message;
}
