/*
* Created on Dec 20, 2004
* Created by Alon Rohter
* Copyright (C) 2004-2005 Aelitis, All Rights Reserved.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* AELITIS, SAS au capital de 46,603.30 euros
* 8 Allee Lenotre, La Grille Royale, 78600 Le Mesnil le Roi, France.
*
*/
package com.aelitis.azureus.core.versioncheck;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.InvocationTargetException;
import java.net.*;
import java.util.*;
import org.gudy.azureus2.core3.config.COConfigurationManager;
import org.gudy.azureus2.core3.config.ParameterListener;
import org.gudy.azureus2.core3.internat.MessageText;
import org.gudy.azureus2.core3.logging.*;
import org.gudy.azureus2.core3.stats.transfer.*;
import org.gudy.azureus2.core3.util.*;
import org.gudy.azureus2.plugins.PluginInterface;
import com.aelitis.azureus.core.AzureusCoreFactory;
import com.aelitis.azureus.core.clientmessageservice.*;
import com.aelitis.azureus.core.networkmanager.admin.NetworkAdmin;
import com.aelitis.azureus.core.networkmanager.admin.NetworkAdminASN;
import com.aelitis.net.udp.uc.PRUDPPacketHandler;
import com.aelitis.net.udp.uc.PRUDPPacketHandlerFactory;
import com.aelitis.net.udp.uc.PRUDPReleasablePacketHandler;
/**
* Client for checking version information from a remote server.
*/
public class VersionCheckClient {
private static final LogIDs LOGID = LogIDs.CORE;
public static final String REASON_UPDATE_CHECK_START = "us";
public static final String REASON_UPDATE_CHECK_PERIODIC = "up";
public static final String REASON_CHECK_SWT = "sw";
public static final String REASON_DHT_EXTENDED_ALLOWED = "dx";
public static final String REASON_DHT_ENABLE_ALLOWED = "de";
public static final String REASON_EXTERNAL_IP = "ip";
public static final String REASON_RECOMMENDED_PLUGINS = "rp";
public static final String REASON_SECONDARY_CHECK = "sc";
private static final String AZ_MSG_SERVER_ADDRESS_V4 = Constants.VERSION_SERVER_V4;
private static final int AZ_MSG_SERVER_PORT = 27001;
private static final String MESSAGE_TYPE_ID = "AZVER";
public static final String HTTP_SERVER_ADDRESS_V4 = AZ_MSG_SERVER_ADDRESS_V4;
public static final int HTTP_SERVER_PORT = 80;
public static final String TCP_SERVER_ADDRESS_V4 = AZ_MSG_SERVER_ADDRESS_V4;
public static final int TCP_SERVER_PORT = 80;
public static final String UDP_SERVER_ADDRESS_V4 = AZ_MSG_SERVER_ADDRESS_V4;
public static final int UDP_SERVER_PORT = 2080;
public static final String AZ_MSG_SERVER_ADDRESS_V6 = Constants.VERSION_SERVER_V6;
public static final String HTTP_SERVER_ADDRESS_V6 = AZ_MSG_SERVER_ADDRESS_V6;
public static final String TCP_SERVER_ADDRESS_V6 = AZ_MSG_SERVER_ADDRESS_V6;
public static final String UDP_SERVER_ADDRESS_V6 = AZ_MSG_SERVER_ADDRESS_V6;
private static final long CACHE_PERIOD = 5*60*1000;
private static boolean secondary_check_done;
static{
VersionCheckClientUDPCodecs.registerCodecs();
}
private static boolean prefer_v6;
static{
COConfigurationManager.addAndFireParameterListener(
"IPV6 Prefer Addresses",
new ParameterListener()
{
public void
parameterChanged(
String name )
{
prefer_v6 = COConfigurationManager.getBooleanParameter( name );
}
});
}
private static final int AT_V4 = 1;
private static final int AT_V6 = 2;
private static final int AT_EITHER = 3;
private static final VersionCheckClient instance = new VersionCheckClient();
private Map last_check_data_v4 = null;
private Map last_check_data_v6 = null;
private final AEMonitor check_mon = new AEMonitor( "versioncheckclient" );
private long last_check_time_v4 = 0;
private long last_check_time_v6 = 0;
private VersionCheckClient() {
/* blank */
}
/**
* Get the singleton instance of the version check client.
* @return version check client
*/
public static VersionCheckClient getSingleton() { return instance; }
/**
* Get the version check reply info.
* @return reply data, possibly cached, if the server was already checked within the last minute
*/
public Map
getVersionCheckInfo(
String reason )
{
return( getVersionCheckInfo( reason, AT_EITHER ));
}
public Map
getVersionCheckInfo(
String reason,
int address_type )
{
if ( address_type == AT_V4 ){
return( getVersionCheckInfoSupport( reason, false, false, false ));
}else if ( address_type == AT_V6 ){
return( getVersionCheckInfoSupport( reason, false, false, true ));
}else{
Map reply = getVersionCheckInfoSupport( reason, false, false, prefer_v6 );
if ( reply == null || reply.size() == 0 ){
reply = getVersionCheckInfoSupport( reason, false, false, !prefer_v6 );
}
return( reply );
}
}
protected Map
getVersionCheckInfoSupport(
String reason,
boolean only_if_cached,
boolean force,
boolean v6 )
{
if ( 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 );
}
catch( UnknownHostException t ) {
// no internet
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 );
}
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();
return last_check_data_v4;
}
}
private boolean
isVersionCheckDataValid(
int address_type )
{
boolean v6_ok = last_check_data_v6 != null && last_check_data_v6.size() > 0;
boolean v4_ok = last_check_data_v4 != null && last_check_data_v4.size() > 0;
if ( address_type == AT_V4 ){
return( v4_ok );
}else if ( address_type == AT_V6 ){
return( v6_ok );
}else{
return( v4_ok | v6_ok );
}
}
public long
getCacheTime(
boolean v6 )
{
return( v6?last_check_time_v6:last_check_time_v4);
}
/**
* Get the ip address seen by the version check server.
* NOTE: This information may be cached, see getVersionCheckInfo().
* @return external ip address, or empty string if no address information found
*/
public String
getExternalIpAddress(
boolean only_if_cached,
boolean v6 )
{
Map reply = getVersionCheckInfoSupport( REASON_EXTERNAL_IP, only_if_cached, false, v6 );
byte[] address = (byte[])reply.get( "source_ip_address" );
if( address != null ) {
return new String( address );
}
return( null );
}
/**
* Is the DHT plugin allowed to be enabled.
* @return true if DHT can be enabled, false if it should not be enabled
*/
public boolean DHTEnableAllowed() {
Map reply = getVersionCheckInfo( REASON_DHT_ENABLE_ALLOWED, AT_EITHER );
boolean res = false;
byte[] value = (byte[])reply.get( "enable_dht" );
if( value != null ) {
res = new String( value ).equalsIgnoreCase( "true" );
}
// we take the view that if the version check failed then we go ahead
// and enable the DHT (i.e. we're being optimistic)
if ( !res ){
res = !isVersionCheckDataValid( AT_EITHER );
}
return res;
}
/**
* Is the DHT allowed to be used by external plugins.
* @return true if extended DHT use is allowed, false if not allowed
*/
public boolean DHTExtendedUseAllowed() {
Map reply = getVersionCheckInfo( REASON_DHT_EXTENDED_ALLOWED, AT_EITHER );
boolean res = false;
byte[] value = (byte[])reply.get( "enable_dht_extended_use" );
if( value != null ) {
res = new String( value ).equalsIgnoreCase( "true" );
}
// be generous and enable extended use if check failed
if ( !res ){
res = !isVersionCheckDataValid( AT_EITHER );
}
return res;
}
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 );
}
/**
* Perform the actual version check by connecting to the version server.
* @param data_to_send version message
* @return version reply
* @throws Exception if the server check connection fails
*/
private Map
performVersionCheck(
Map data_to_send,
boolean use_az_message,
boolean use_http,
boolean v6 )
throws Exception
{
Exception error = null;
Map reply = null;
if ( use_az_message ){
try{
reply = executeAZMessage( data_to_send, v6 );
reply.put( "protocol_used", "AZMSG" );
}
catch (IOException e) {
error = e;
}
catch (Exception e) {
Debug.printStackTrace( e );
error = e;
}
}
if ( reply == null && use_http ){
try{
reply = executeHTTP( data_to_send, v6 );
reply.put( "protocol_used", "HTTP" );
error = null;
}
catch (IOException e) {
error = e;
}
catch (Exception e){
Debug.printStackTrace(e);
error = e;
}
}
if ( error != null ){
throw( error );
}
if (Logger.isEnabled())
Logger.log(new LogEvent(LOGID, "VersionCheckClient server "
+ "version check successful. Received " + reply.size()
+ " reply keys."));
if ( v6 ){
last_check_time_v6 = SystemTime.getCurrentTime();
}else{
last_check_time_v4 = SystemTime.getCurrentTime();
}
return reply;
}
private Map
executeAZMessage(
Map data_to_send,
boolean v6 )
throws Exception
{
String host = v6?AZ_MSG_SERVER_ADDRESS_V6:AZ_MSG_SERVER_ADDRESS_V4;
if (Logger.isEnabled())
Logger.log(new LogEvent(LOGID, "VersionCheckClient retrieving "
+ "version information from " + host + ":" + AZ_MSG_SERVER_PORT));
ClientMessageService msg_service = null;
Map reply = null;
try{
msg_service = ClientMessageServiceClient.getServerService( host, AZ_MSG_SERVER_PORT, MESSAGE_TYPE_ID );
msg_service.sendMessage( data_to_send ); //send our version message
reply = msg_service.receiveMessage(); //get the server reply
preProcessReply( reply, v6 );
}finally{
if ( msg_service != null ){
msg_service.close();
}
}
return( reply );
}
private Map
executeHTTP(
Map data_to_send,
boolean v6 )
throws Exception
{
String host = v6?HTTP_SERVER_ADDRESS_V6:HTTP_SERVER_ADDRESS_V4;
if (Logger.isEnabled())
Logger.log(new LogEvent(LOGID, "VersionCheckClient retrieving "
+ "version information from " + host + ":" + HTTP_SERVER_PORT + " via HTTP" ));
String url_str = "http://" + host + (HTTP_SERVER_PORT==80?"":(":" + HTTP_SERVER_PORT)) + "/version?";
url_str += URLEncoder.encode( new String( BEncoder.encode( data_to_send ), "ISO-8859-1" ), "ISO-8859-1" );
URL url = new URL( url_str );
HttpURLConnection url_connection = (HttpURLConnection)url.openConnection();
url_connection.connect();
try{
InputStream is = url_connection.getInputStream();
Map reply = BDecoder.decode( new BufferedInputStream( is ));
preProcessReply( reply, v6 );
return( reply );
}finally{
url_connection.disconnect();
}
}
public String
getHTTPGetString(
boolean for_proxy,
boolean v6 )
{
return( getHTTPGetString( new HashMap(), for_proxy, v6 ));
}
private String
getHTTPGetString(
Map content,
boolean for_proxy,
boolean v6 )
{
String host = v6?HTTP_SERVER_ADDRESS_V6:HTTP_SERVER_ADDRESS_V4;
String get_str = "GET " + (for_proxy?("http://" + host + ":" + HTTP_SERVER_PORT ):"") +"/version?";
try{
get_str += URLEncoder.encode( new String( BEncoder.encode( content ), "ISO-8859-1" ), "ISO-8859-1" );
}catch( Throwable e ){
}
get_str +=" HTTP/1.1" + "\015\012" + "\015\012";
return( get_str );
}
private Map
executeTCP(
Map data_to_send,
InetAddress bind_ip,
int bind_port,
boolean v6 )
throws Exception
{
String host = v6?TCP_SERVER_ADDRESS_V6:TCP_SERVER_ADDRESS_V4;
if (Logger.isEnabled())
Logger.log(new LogEvent(LOGID, "VersionCheckClient retrieving "
+ "version information from " + host + ":" + TCP_SERVER_PORT + " via TCP" ));
String get_str = getHTTPGetString( data_to_send, false, v6 );
Socket socket = null;
try{
socket = new Socket();
if ( bind_ip != null ){
socket.bind( new InetSocketAddress( bind_ip, bind_port ));
}else if ( bind_port != 0 ){
socket.bind( new InetSocketAddress( bind_port ));
}
socket.setSoTimeout( 10000 );
socket.connect( new InetSocketAddress( host, TCP_SERVER_PORT ), 10000 );
OutputStream os = socket.getOutputStream();
os.write( get_str.getBytes( "ISO-8859-1" ));
os.flush();
InputStream is = socket.getInputStream();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int total_len = 0;
while( true ){
int len = is.read( buffer );
if ( len <= 0 ){
break;
}
total_len += len;
if ( total_len > 16000 ){
throw( new IOException( "reply too large" ));
}
baos.write( buffer, 0, len );
}
byte[] reply_bytes = baos.toByteArray();
for (int i=3;i<reply_bytes.length;i++){
if ( reply_bytes[i-3]== (byte)'\015' &&
reply_bytes[i-2]== (byte)'\012' &&
reply_bytes[i-1]== (byte)'\015' &&
reply_bytes[i-0]== (byte)'\012' ){
Map reply = BDecoder.decode( new BufferedInputStream( new ByteArrayInputStream( reply_bytes, i+1, reply_bytes.length - (i+1 ))));
preProcessReply( reply, v6 );
return( reply );
}
}
throw( new Exception( "Invalid reply: " + new String( reply_bytes )));
}finally{
if ( socket != null ){
try{
socket.close();
}catch( Throwable e ){
}
}
}
}
private Map
executeUDP(
Map data_to_send,
InetAddress bind_ip,
int bind_port,
boolean v6 )
throws Exception
{
String host = v6?UDP_SERVER_ADDRESS_V6:UDP_SERVER_ADDRESS_V4;
PRUDPReleasablePacketHandler handler = PRUDPPacketHandlerFactory.getReleasableHandler( bind_port );
PRUDPPacketHandler packet_handler = handler.getHandler();
long timeout = 5;
Random random = new Random();
try{
Exception last_error = null;
packet_handler.setExplicitBindAddress( bind_ip );
for (int i=0;i<3;i++){
try{
// connection ids for requests must always have their msb set...
// apart from the original darn udp tracker spec....
long connection_id = 0x8000000000000000L | random.nextLong();
VersionCheckClientUDPRequest request_packet = new VersionCheckClientUDPRequest( connection_id );
request_packet.setPayload( data_to_send );
VersionCheckClientUDPReply reply_packet = (VersionCheckClientUDPReply)packet_handler.sendAndReceive( null, request_packet, new InetSocketAddress( host, UDP_SERVER_PORT ), timeout );
Map reply = reply_packet.getPayload();
preProcessReply( reply, v6 );
return( reply );
}catch( Exception e){
last_error = e;
timeout = timeout * 2;
}
}
if ( last_error != null ){
throw( last_error );
}
throw( new Exception( "Timeout" ));
}finally{
packet_handler.setExplicitBindAddress( null );
handler.release();
}
}
protected void
preProcessReply(
Map reply,
final boolean v6 )
{
NetworkAdmin admin = NetworkAdmin.getSingleton();
try{
byte[] address = (byte[])reply.get( "source_ip_address" );
InetAddress my_ip = InetAddress.getByName( new String( address ));
NetworkAdminASN old_asn = admin.getCurrentASN();
NetworkAdminASN new_asn = admin.lookupASN( my_ip );
if ( !new_asn.sameAs( old_asn )){
// kick off a secondary version check to communicate the new information
if ( !secondary_check_done ){
secondary_check_done = true;
new AEThread( "Secondary version check", true )
{
public void
runSupport()
{
getVersionCheckInfoSupport( REASON_SECONDARY_CHECK, false, true, v6 );
}
}.start();
}
}
}catch( Throwable e ){
Debug.printStackTrace(e);
}
Long as_advice = (Long)reply.get( "as_advice" );
if ( as_advice != null ){
NetworkAdminASN current_asn = admin.getCurrentASN();
String asn = current_asn.getASName();
if ( asn != null ){
long advice = as_advice.longValue();
if ( advice != 0 ){
// require crypto
String done_asn = COConfigurationManager.getStringParameter( "ASN Advice Followed", "" );
if ( !done_asn.equals( asn )){
COConfigurationManager.setParameter( "ASN Advice Followed", asn );
boolean change = advice == 1 || advice == 2;
boolean alert = advice == 1 || advice == 3;
if ( !COConfigurationManager.getBooleanParameter( "network.transport.encrypted.require" )){
if ( change ){
COConfigurationManager.setParameter( "network.transport.encrypted.require", true );
}
if ( alert ){
String msg =
MessageText.getString(
"crypto.alert.as.warning",
new String[]{ asn });
Logger.log( new LogAlert( false, LogAlert.AT_WARNING, msg ));
}
}
}
}
}
}
// set ui.toolbar.uiswitcher based on instructions from tracker
// Really shouldn't be in VersionCheck client, but instead have some
// listener and have the code elsewhere. Simply calling
//getVersionCheckInfo from "code elsewhere" (to get the cached result)
//caused a deadlock at startup.
Long lEnabledUISwitcher = (Long) reply.get("ui.toolbar.uiswitcher");
if (lEnabledUISwitcher != null) {
COConfigurationManager.setBooleanDefault("ui.toolbar.uiswitcher",
lEnabledUISwitcher.longValue() == 1);
}
}
public InetAddress
getExternalIpAddressHTTP(
boolean v6 )
throws Exception
{
Map reply = executeHTTP( new HashMap(), v6 );
byte[] address = (byte[])reply.get( "source_ip_address" );
return( InetAddress.getByName( new String( address )));
}
public InetAddress
getExternalIpAddressTCP(
InetAddress bind_ip,
int bind_port,
boolean v6 )
throws Exception
{
Map reply = executeTCP( new HashMap(), bind_ip, bind_port, v6 );
byte[] address = (byte[])reply.get( "source_ip_address" );
return( InetAddress.getByName( new String( address )));
}
public InetAddress
getExternalIpAddressUDP(
InetAddress bind_ip,
int bind_port,
boolean v6 )
throws Exception
{
Map reply = executeUDP( new HashMap(), bind_ip, bind_port, v6 );
byte[] address = (byte[])reply.get( "source_ip_address" );
return( InetAddress.getByName( new String( address )));
}
/**
* Construct the default version check message.
* @return message to send
*/
private Map constructVersionCheckMessage( String reason ) {
Map message = new HashMap();
message.put( "appid", SystemProperties.getApplicationIdentifier());
message.put( "version", Constants.AZUREUS_VERSION );
String id = COConfigurationManager.getStringParameter( "ID", null );
boolean send_info = COConfigurationManager.getBooleanParameter( "Send Version Info" );
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 );
if( id != null && send_info ) {
message.put( "id", id );
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
if ( last_send_time != -1 && last_send_time < current_send_time ){
// tims 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());
}
String as = COConfigurationManager.getStringParameter( "ASN AS", null );
if ( as != null ){
// there was borkage with DNS based queries that left leading " on AS
if ( as.startsWith( "\"" )){
as = as.substring( 1 ).trim();
COConfigurationManager.setParameter( "ASN AS", as );
}
message.put( "ip_as", as );
}
String asn = COConfigurationManager.getStringParameter( "ASN ASN", null );
if ( asn != null ){
if ( asn.length() > 64 ){
asn = asn.substring( 0, 64 );
}
message.put( "ip_asn", asn );
}
String ui = COConfigurationManager.getStringParameter("ui");
if (ui.length() > 0) {
message.put("ui", ui);
}
// 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);
if ( AzureusCoreFactory.isCoreAvailable()){
//installed plugin IDs
PluginInterface[] plugins = AzureusCoreFactory.getSingleton().getPluginManager().getPluginInterfaces();
List pids = new ArrayList();
for (int i=0;i<plugins.length;i++){
String pid = plugins[i].getPluginID();
String info = (String)plugins[i].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 );
}
}
message.put( "plugins", pids );
}
}
//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 );
if( send_info ) {
Integer swt_version = (Integer)c.getMethod( "getVersion", new Class[]{} ).invoke( null, new Object[]{} );
message.put( "swt_version", new Long( swt_version.longValue() ) );
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(); }
boolean using_phe = COConfigurationManager.getBooleanParameter( "network.transport.encrypted.require" );
message.put( "using_phe", using_phe ? new Long(1) : new Long(0) );
return message;
}
public static void
main(
String[] args )
{
try{
COConfigurationManager.initialise();
boolean v6= false;
System.out.println( "UDP: " + getSingleton().getExternalIpAddressUDP(null,0,v6));
System.out.println( "TCP: " + getSingleton().getExternalIpAddressTCP(null,0,v6));
System.out.println( "HTTP: " + getSingleton().getExternalIpAddressHTTP(v6));
}catch( Throwable e){
e.printStackTrace();
}
}
}
|
