X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fbin%2FCache.java;h=6648099eac8e8195fceb7df691cd9a8e7c5c84ff;hb=245686954f67953e2dda80efc8c7a5c6d6b965e1;hp=621b74b4499f573da8779e2b035b26b1879cdfd1;hpb=e19524773e4547406d2ce5f9c91a536c3bc38f24;p=jalview.git diff --git a/src/jalview/bin/Cache.java b/src/jalview/bin/Cache.java index 621b74b..6648099 100755 --- a/src/jalview/bin/Cache.java +++ b/src/jalview/bin/Cache.java @@ -29,6 +29,8 @@ import java.io.InputStream; import java.io.InputStreamReader; import java.io.PrintWriter; import java.io.StringWriter; +import java.net.Authenticator; +import java.net.PasswordAuthentication; import java.net.URL; import java.text.DateFormat; import java.text.SimpleDateFormat; @@ -276,7 +278,19 @@ public class Cache System.getProperty("http.proxyHost"), System.getProperty("http.proxyPort"), System.getProperty("https.proxyHost"), - System.getProperty("https.proxyPort") }; + System.getProperty("https.proxyPort"), + System.getProperty("http.proxyUser"), + System.getProperty("http.proxyPassword"), + System.getProperty("https.proxyUser"), + System.getProperty("https.proxyPassword"), + System.getProperty("http.nonProxyHosts") }; + + public final static String PROXYTYPE_NONE = "none"; + + // "false" and "true" for backward compatibility + public final static String PROXYTYPE_SYSTEM = "false"; + + public final static String PROXYTYPE_CUSTOM = "true"; /** Jalview Properties */ public static Properties applicationProperties = new Properties() @@ -412,34 +426,35 @@ public class Cache // PROXY TYPE settings (now three options "none", "false", "true", but using // backward compatible strings) - String proxyType = getDefault("USE_PROXY", "false"); + String proxyType = getDefault("USE_PROXY", PROXYTYPE_SYSTEM); // default to upgrading old settings switch (proxyType) { - case "none": - setProxyProperties(null, null, null, null); + case PROXYTYPE_NONE: + setProxyProperties(null, null, null, null, null, null, null, null); break; - case "false": // use system settings + case PROXYTYPE_SYSTEM: // use system settings resetProxyProperties(); break; - case "true": // use specified proxy settings + case PROXYTYPE_CUSTOM: // use specified proxy settings String httpHost = getDefault("PROXY_SERVER", ""); String httpPort = getDefault("PROXY_PORT", "8080"); String httpsHost = getDefault("PROXY_SERVER_HTTPS", httpHost); String httpsPort = getDefault("PROXY_PORT_HTTPS", httpPort); - setProxyProperties(httpHost, httpPort, httpsHost, httpsPort); + String httpUser = getDefault("PROXY_AUTH_USER", null); + String httpPassword = getDefault("PROXY_AUTH_PASSWORD", null); + // https.proxyUser and https.proxyPassword are not able to be + // independently set in Preferences yet + String httpsUser = getDefault("PROXY_AUTH_USER_HTTPS", httpUser); + String httpsPassword = getDefault("PROXY_AUTH_PASSWORD_HTTPS", + httpPassword); + setProxyProperties(httpHost, httpPort, httpsHost, httpsPort, httpUser, + httpPassword, httpsUser, httpsPassword); break; default: String message = "Incorrect PROXY_TYPE - should be 'none' (clear proxy properties), 'false' (system settings), 'true' (custom settings): " + proxyType; - if (Cache.log == null) - { - System.out.println(message); - } - else - { - Cache.log.warn(message); - } + Cache.warn(message); } // LOAD THE AUTHORS FROM THE authors.props file @@ -1256,72 +1271,183 @@ public class Cache public static void resetProxyProperties() { setProxyProperties(startupProxyProperties[0], startupProxyProperties[1], - startupProxyProperties[2], startupProxyProperties[3]); + startupProxyProperties[2], startupProxyProperties[3], + startupProxyProperties[4], startupProxyProperties[5], + startupProxyProperties[6], startupProxyProperties[7]); StringBuilder sb = new StringBuilder(); sb.append("Setting proxy properties to: http.proxyHost=") .append(startupProxyProperties[0]).append(", http.proxyPort=") - .append(startupProxyProperties[1]).append(", https.proxyHost=") - .append(startupProxyProperties[2]).append(", https.proxyPort=") - .append(startupProxyProperties[3]); - if (Cache.log == null) - { - System.err.println(sb.toString()); - } - else - { - Cache.log.debug(sb.toString()); - } + .append(startupProxyProperties[1]) + .append(startupProxyProperties[4] != null + && !startupProxyProperties[4].isEmpty() + ? " [" + startupProxyProperties[4] + "]" + : "") + .append(", https.proxyHost=").append(startupProxyProperties[2]) + .append(", https.proxyPort=").append(startupProxyProperties[3]) + .append(startupProxyProperties[6] != null + && !startupProxyProperties[6].isEmpty() + ? " [" + startupProxyProperties[6] + "]" + : ""); + + Cache.debug(sb.toString()); } - public static void setProxyProperties(String host, String port) + public static void setProxyProperties(String httpHost, String httpPort, + String httpsHost, String httpsPort, String httpUser, + String httpPassword) { - setProxyProperties(host, port, host, port); + setProxyProperties(httpHost, httpPort, httpsHost, httpsPort, httpUser, + httpPassword, httpUser, httpPassword); } public static void setProxyProperties(String httpHost, String httpPort, - String httpsHost, String httpsPort) + String httpsHost, String httpsPort, String httpUser, + String httpPassword, String httpsUser, String httpsPassword) { - // cannot set property to null -- use clearProperty instead - - // http.proxyHost - if (httpHost == null) + setOrClearSystemProperty("http.proxyHost", httpHost); + setOrClearSystemProperty("http.proxyPort", httpPort); + setOrClearSystemProperty("https.proxyHost", httpsHost); + setOrClearSystemProperty("https.proxyPort", httpsPort); + setOrClearSystemProperty("http.proxyUser", httpUser); + setOrClearSystemProperty("http.proxyPassword", httpPassword); + setOrClearSystemProperty("https.proxyUser", httpsUser); + setOrClearSystemProperty("https.proxyPassword", httpsPassword); + if (httpUser != null || httpsUser != null) { - System.clearProperty("http.proxyHost"); + try + { + Authenticator.setDefault(new Authenticator() + { + @Override + protected PasswordAuthentication getPasswordAuthentication() + { + if (getRequestorType() == RequestorType.PROXY) + { + try + { + if (getRequestingScheme().equalsIgnoreCase("http") + && getRequestingHost().equalsIgnoreCase(httpHost) + && getRequestingPort() == Integer.valueOf(httpPort)) + { + return new PasswordAuthentication(httpUser, + httpPassword == null ? new char[] {} + : httpPassword.toCharArray()); + } + if (getRequestingScheme().equalsIgnoreCase("https") + && getRequestingHost().equalsIgnoreCase(httpsHost) + && getRequestingPort() == Integer + .valueOf(httpsPort)) + { + return new PasswordAuthentication(httpsUser, + httpsPassword == null ? new char[] {} + : httpsPassword.toCharArray()); + } + } catch (NumberFormatException e) + { + Cache.error("Problem with proxy port values [http:" + + httpPort + ", https:" + httpsPort + "]"); + } + } + // non proxy request + return null; + } + }); + // required to re-enable basic authentication (should be okay for a + // local proxy) + System.setProperty("jdk.http.auth.tunneling.disabledSchemes", ""); + } catch (SecurityException e) + { + Cache.error("Could not set default Authenticator"); + Cache.debug(getStackTraceString(e)); + } } else { - System.setProperty("http.proxyHost", httpHost); + // reset the Authenticator to protect http.proxyUser and + // http.proxyPassword Just In Case + Authenticator.setDefault(new Authenticator() + { + @Override + protected PasswordAuthentication getPasswordAuthentication() + { + return null; + } + }); } - // http.proxyPort - if (httpPort == null) + // clear localhost from proxying unless nonProxyHosts already set (not + // currently configurable in Preferences) + String nonProxyHosts = startupProxyProperties[8]; + System.setProperty("http.nonProxyHosts", + nonProxyHosts == null ? "localhost" : nonProxyHosts); + } + + public static void setOrClearSystemProperty(String key, String value) + { + if (key == null) + { + return; + } + if (value == null) { - System.clearProperty("http.proxyPort"); + System.clearProperty(key); } else { - System.setProperty("http.proxyPort", httpPort); + System.setProperty(key, value); } + } + + public final static int DEBUG = 10; + + public final static int INFO = 20; + + public final static int WARN = 30; - // https.proxyHost - if (httpsHost == null) + public final static int ERROR = 40; + + public static boolean println(int level, String message) + { + if (Cache.log == null) { - System.clearProperty("https.proxyHost"); + if (level >= ERROR) + System.err.println(message); + else + System.out.println(message); + return false; } - else + if (level >= WARN) { - System.setProperty("https.proxyHost", httpsHost); + Cache.log.warn(message); } - - // https.proxyPort - if (httpsPort == null) + else if (level >= INFO) { - System.clearProperty("https.proxyPort"); + Cache.log.info(message); } else { - System.setProperty("https.proxyPort", httpsPort); + Cache.log.debug(message); } + return true; + } + + public static void debug(String message) + { + println(DEBUG, message); + } + public static void info(String message) + { + println(INFO, message); + } + + public static void warn(String message) + { + println(WARN, message); + } + + public static void error(String message) + { + println(ERROR, message); } }