public void configParameterChanged(ConfigParameter param) {
nick =
plugin_interface
.getPluginconfig()
.getPluginStringParameter("nick", "Guest" + (int) (Math.random() * 100000));
if (nick.startsWith("System") || nick.startsWith("system")) {
nick = "Guest" + (int) (Math.random() * 100000);
}
}
public void initialize(PluginInterface pi) {
plugin_interface = pi;
formatters = plugin_interface.getUtilities().getFormatters();
genericTorrent = loadTorrent(resTorrent);
nick =
plugin_interface
.getPluginconfig()
.getPluginStringParameter("nick", "Guest" + (int) (Math.random() * 100000));
active = plugin_interface.getPluginconfig().getPluginBooleanParameter("enable", true);
if (active) {
listeners = new ArrayList();
listenersDownload = new ArrayList();
controller = new PeerControllerImpl(this, nick);
controller.addMessageListener(this);
controller.initialize();
controller.startPeerProcessing();
}
}
protected void setDeviceStats(String USN, String stat_key, long value) {
String key = "upnp.device.stats." + stat_key;
PluginConfig pc = plugin_interface.getPluginconfig();
Map counts = pc.getPluginMapParameter(key, new HashMap());
counts.put(USN, new Long(value));
pc.getPluginMapParameter(key, counts);
}
public void rootDeviceFound(UPnPRootDevice device) {
incrementDeviceStats(device.getUSN(), "found");
checkDeviceStats(device);
try {
int interesting = processDevice(device.getDevice());
if (interesting > 0) {
try {
this_mon.enter();
root_info_map.put(device.getLocation(), device.getInfo());
Iterator<String> it = root_info_map.values().iterator();
String all_info = "";
List reported_info = new ArrayList();
while (it.hasNext()) {
String info = (String) it.next();
if (info != null && !reported_info.contains(info)) {
reported_info.add(info);
all_info += (all_info.length() == 0 ? "" : ",") + info;
}
}
if (all_info.length() > 0) {
plugin_interface.getPluginconfig().setPluginParameter("plugin.info", all_info);
}
} finally {
this_mon.exit();
}
}
} catch (Throwable e) {
log.log("Root device processing fails", e);
}
}
protected long getDeviceStats(String USN, String stat_key) {
String key = "upnp.device.stats." + stat_key;
PluginConfig pc = plugin_interface.getPluginconfig();
Map counts = pc.getPluginMapParameter(key, new HashMap());
Long count = (Long) counts.get(USN);
if (count == null) {
return (0);
}
return (count.longValue());
}
protected void updateIgnoreList() {
try {
String param = "";
if (ignore_bad_devices.getValue()) {
PluginConfig pc = plugin_interface.getPluginconfig();
Map ignored = pc.getPluginMapParameter("upnp.device.ignorelist", new HashMap());
Iterator it = ignored.entrySet().iterator();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry) it.next();
Map value = (Map) entry.getValue();
param += "\n " + entry.getKey() + ": " + new String((byte[]) value.get("Location"));
}
if (ignored.size() > 0) {
log.log("Devices currently being ignored: " + param);
}
}
String text =
plugin_interface
.getUtilities()
.getLocaleUtilities()
.getLocalisedMessageText("upnp.ignorebaddevices.info", new String[] {param});
ignored_devices_list.setLabelText(text);
} catch (Throwable e) {
Debug.printStackTrace(e);
}
}
protected void ignoreDevice(String USN, URL location) {
// only take note of this if enabled to do so
if (ignore_bad_devices.getValue()) {
try {
PluginConfig pc = plugin_interface.getPluginconfig();
Map ignored = pc.getPluginMapParameter("upnp.device.ignorelist", new HashMap());
Map entry = (Map) ignored.get(USN);
if (entry == null) {
entry = new HashMap();
entry.put("Location", location.toString().getBytes());
ignored.put(USN, entry);
pc.setPluginMapParameter("upnp.device.ignorelist", ignored);
updateIgnoreList();
String text =
plugin_interface
.getUtilities()
.getLocaleUtilities()
.getLocalisedMessageText(
"upnp.ignorebaddevices.alert", new String[] {location.toString()});
log.logAlertRepeatable(LoggerChannel.LT_WARNING, text);
}
} catch (Throwable e) {
Debug.printStackTrace(e);
}
}
}
protected long incrementDeviceStats(String USN, String stat_key) {
String key = "upnp.device.stats." + stat_key;
PluginConfig pc = plugin_interface.getPluginconfig();
Map counts = pc.getPluginMapParameter(key, new HashMap());
Long count = (Long) counts.get(USN);
if (count == null) {
count = new Long(1);
} else {
count = new Long(count.longValue() + 1);
}
counts.put(USN, count);
pc.getPluginMapParameter(key, counts);
return (count.longValue());
}
public void setNick(String nick) {
this.nick = nick;
plugin_interface.getPluginconfig().setPluginParameter("nick", nick);
}
protected void addService(UPnPWANConnection wan_service) throws UPnPException {
wan_service.addListener(this);
mapping_manager.serviceFound(wan_service);
try {
this_mon.enter();
log.log(
" Found "
+ (wan_service.getGenericService().getServiceType().indexOf("PPP") == -1
? "WANIPConnection"
: "WANPPPConnection"));
UPnPWANConnectionPortMapping[] ports;
String usn = wan_service.getGenericService().getDevice().getRootDevice().getUSN();
if (getDeviceStats(usn, STATS_READ_OK) == 0 && getDeviceStats(usn, STATS_READ_BAD) > 2) {
ports = new UPnPWANConnectionPortMapping[0];
wan_service.periodicallyRecheckMappings(false);
log.log(" Not reading port mappings from device due to previous failures");
} else {
ports = wan_service.getPortMappings();
}
for (int j = 0; j < ports.length; j++) {
log.log(
" mapping ["
+ j
+ "] "
+ ports[j].getExternalPort()
+ "/"
+ (ports[j].isTCP() ? "TCP" : "UDP")
+ " ["
+ ports[j].getDescription()
+ "] -> "
+ ports[j].getInternalHost());
}
services.add(
new UPnPPluginService(
wan_service,
ports,
alert_success_param,
grab_ports_param,
alert_other_port_param,
release_mappings_param));
if (services.size() > 1) {
// check this isn't a single device with multiple services
String new_usn = wan_service.getGenericService().getDevice().getRootDevice().getUSN();
boolean multiple_found = false;
for (int i = 0; i < services.size() - 1; i++) {
UPnPPluginService service = (UPnPPluginService) services.get(i);
String existing_usn =
service.getService().getGenericService().getDevice().getRootDevice().getUSN();
if (!new_usn.equals(existing_usn)) {
multiple_found = true;
break;
}
}
if (multiple_found) {
PluginConfig pc = plugin_interface.getPluginconfig();
if (!pc.getPluginBooleanParameter("upnp.device.multipledevices.warned", false)) {
pc.setPluginParameter("upnp.device.multipledevices.warned", true);
String text = MessageText.getString("upnp.alert.multipledevice.warning");
log.logAlertRepeatable(LoggerChannel.LT_WARNING, text);
}
}
}
checkState();
} finally {
this_mon.exit();
}
}
protected RPReply processRequestSupport(
RPRequest request, RPRequestAccessController access_controller) {
try {
RPObject object = request.getObject();
String method = request.getMethod();
if (object == null && method.equals("getSingleton")) {
RPObject pi = request.createRemotePluginInterface(plugin_interface);
RPReply reply = new RPReply(pi);
return (reply);
} else if (object == null && method.equals("getDownloads")) {
RPPluginInterface pi = request.createRemotePluginInterface(plugin_interface);
// short cut method for quick access to downloads
// used by GTS
RPObject dm =
(RPObject) pi._process(new RPRequest(null, "getDownloadManager", null)).getResponse();
RPReply rep = dm._process(new RPRequest(null, "getDownloads", null));
rep.setProperty("azureus_name", pi.azureus_name);
rep.setProperty("azureus_version", pi.azureus_version);
return (rep);
} else if (object == null) {
throw new RPNoObjectIDException();
} else {
// System.out.println( "Request: con = " + request.getConnectionId() + ", req = " +
// request.getRequestId() + ", client = " +
// request.getClientIP());
object = RPObject._lookupLocal(object._getOID());
// _setLocal synchronizes the RP objects with their underlying
// plugin objects
object._setLocal();
if (method.equals("_refresh")) {
RPReply reply = new RPReply(object);
return (reply);
} else {
String name = object._getName();
if (access_controller != null) {
access_controller.checkAccess(name, request);
}
RPReply reply = object._process(request);
if (name.equals("IPFilter")
&& method.equals("setInRangeAddressesAreAllowed[boolean]")
&& request.getClientIP() != null) {
String client_ip = request.getClientIP();
// problem here, if someone changes the mode here they'll lose their
// connection coz they'll be denied access :)
boolean b = ((Boolean) request.getParams()[0]).booleanValue();
LoggerChannel[] channels = plugin_interface.getLogger().getChannels();
IPFilter filter = plugin_interface.getIPFilter();
if (b) {
if (filter.isInRange(client_ip)) {
// we gotta add the client's address range
for (int i = 0; i < channels.length; i++) {
channels[i].log(
LoggerChannel.LT_INFORMATION,
"Adding range for client '"
+ client_ip
+ "' as allow/deny flag changed to allow");
}
filter.createAndAddRange(
"auto-added for remote interface", client_ip, client_ip, false);
filter.save();
plugin_interface.getPluginconfig().save();
}
} else {
IPRange[] ranges = filter.getRanges();
for (int i = 0; i < ranges.length; i++) {
if (ranges[i].isInRange(client_ip)) {
for (int j = 0; j < channels.length; j++) {
channels[j].log(
LoggerChannel.LT_INFORMATION,
"deleting range '"
+ ranges[i].getStartIP()
+ "-"
+ ranges[i].getEndIP()
+ "' for client '"
+ client_ip
+ "' as allow/deny flag changed to deny");
}
ranges[i].delete();
}
}
filter.save();
plugin_interface.getPluginconfig().save();
}
}
return (reply);
}
}
} catch (RPException e) {
return (new RPReply(e));
} catch (Exception e) {
throw new RPInternalProcessException(e);
}
}
protected Map getVersionCheckInfoSupport(
String reason, boolean only_if_cached, boolean force, boolean v6) {
try {
synchronized (listeners) {
if (REASON_UPDATE_CHECK_START.equals(reason)) {
startCheckRan = true;
}
for (VersionCheckClientListener l : listeners) {
l.versionCheckStarted(reason);
}
}
} catch (Throwable t) {
Debug.out(t);
}
if (v6) {
if (enable_v6) {
try {
check_mon.enter();
long time_diff = SystemTime.getCurrentTime() - last_check_time_v6;
force = force || time_diff > CACHE_PERIOD || time_diff < 0;
if (last_check_data_v6 == null || last_check_data_v6.size() == 0 || force) {
// if we've never checked before then we go ahead even if the "only_if_cached"
// flag is set as its had not chance of being cached yet!
if (only_if_cached && last_check_data_v6 != null) {
return (new HashMap());
}
try {
last_check_data_v6 =
performVersionCheck(constructVersionCheckMessage(reason), true, true, true);
if (last_check_data_v6 != null && last_check_data_v6.size() > 0) {
COConfigurationManager.setParameter("versioncheck.cache.v6", last_check_data_v6);
}
} catch (SocketException t) {
// internet is broken
// Debug.out(t.getClass().getName() + ": " + t.getMessage());
} catch (UnknownHostException t) {
// dns is broken
// Debug.out(t.getClass().getName() + ": " + t.getMessage());
} catch (Throwable t) {
Debug.out(t);
last_check_data_v6 = new HashMap();
}
} else {
Logger.log(
new LogEvent(
LOGID,
"VersionCheckClient is using "
+ "cached version check info. Using "
+ last_check_data_v6.size()
+ " reply keys."));
}
} finally {
check_mon.exit();
}
}
if (last_check_data_v6 == null) last_check_data_v6 = new HashMap();
return last_check_data_v6;
} else {
try {
check_mon.enter();
long time_diff = SystemTime.getCurrentTime() - last_check_time_v4;
force = force || time_diff > CACHE_PERIOD || time_diff < 0;
if (last_check_data_v4 == null || last_check_data_v4.size() == 0 || force) {
// if we've never checked before then we go ahead even if the "only_if_cached"
// flag is set as its had not chance of being cached yet!
if (only_if_cached && last_check_data_v4 != null) {
return (new HashMap());
}
try {
last_check_data_v4 =
performVersionCheck(constructVersionCheckMessage(reason), true, true, false);
if (last_check_data_v4 != null && last_check_data_v4.size() > 0) {
COConfigurationManager.setParameter("versioncheck.cache.v4", last_check_data_v4);
}
// clear down any plugin-specific data that has successfully been sent to the version
// server
try {
if (AzureusCoreFactory.isCoreAvailable()) {
// installed plugin IDs
PluginInterface[] plugins =
AzureusCoreFactory.getSingleton().getPluginManager().getPluginInterfaces();
for (int i = 0; i < plugins.length; i++) {
PluginInterface plugin = plugins[i];
Map data =
plugin
.getPluginconfig()
.getPluginMapParameter("plugin.versionserver.data", null);
if (data != null) {
plugin
.getPluginconfig()
.setPluginMapParameter("plugin.versionserver.data", new HashMap());
}
}
}
} catch (Throwable e) {
}
} catch (UnknownHostException t) {
// no internet
Debug.outNoStack(
"VersionCheckClient - " + t.getClass().getName() + ": " + t.getMessage());
} catch (IOException t) {
// General connection problem.
Debug.outNoStack(
"VersionCheckClient - " + t.getClass().getName() + ": " + t.getMessage());
} catch (Throwable t) {
Debug.out(t);
last_check_data_v4 = new HashMap();
}
} else {
if (Logger.isEnabled())
Logger.log(
new LogEvent(
LOGID,
"VersionCheckClient is using "
+ "cached version check info. Using "
+ last_check_data_v4.size()
+ " reply keys."));
}
} finally {
check_mon.exit();
}
if (last_check_data_v4 == null) last_check_data_v4 = new HashMap();
last_feature_flag_cache_time = 0;
return last_check_data_v4;
}
}
/**
* 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;
}