X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fbin%2FCache.java;h=594046fc07976370f0650f290cc3f4e01f1ba965;hb=9092d9f4c2231645b58968e964c858e010be14e2;hp=3c919cb4d2f76b4083ef05177e1315b84320ea9e;hpb=3da878124135ff033f42d19d8733891b09e953cd;p=jalview.git diff --git a/src/jalview/bin/Cache.java b/src/jalview/bin/Cache.java index 3c919cb..594046f 100755 --- a/src/jalview/bin/Cache.java +++ b/src/jalview/bin/Cache.java @@ -20,17 +20,6 @@ */ package jalview.bin; -import jalview.datamodel.PDBEntry; -import jalview.gui.UserDefinedColours; -import jalview.schemes.ColourSchemeLoader; -import jalview.schemes.ColourSchemes; -import jalview.schemes.UserColourScheme; -import jalview.structure.StructureImportSettings; -import jalview.urls.IdOrgSettings; -import jalview.util.ColorUtils; -import jalview.util.Platform; -import jalview.ws.sifts.SiftsSettings; - import java.awt.Color; import java.io.BufferedReader; import java.io.File; @@ -38,8 +27,14 @@ import java.io.FileInputStream; import java.io.FileOutputStream; 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; +import java.util.Arrays; import java.util.Collections; import java.util.Date; import java.util.Enumeration; @@ -47,12 +42,29 @@ import java.util.Locale; import java.util.Properties; import java.util.StringTokenizer; import java.util.TreeSet; +import java.util.regex.Pattern; + +import javax.swing.LookAndFeel; +import javax.swing.UIManager; import org.apache.log4j.ConsoleAppender; import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.apache.log4j.SimpleLayout; +import jalview.datamodel.PDBEntry; +import jalview.gui.Preferences; +import jalview.gui.UserDefinedColours; +import jalview.schemes.ColourSchemeLoader; +import jalview.schemes.ColourSchemes; +import jalview.schemes.UserColourScheme; +import jalview.structure.StructureImportSettings; +import jalview.urls.IdOrgSettings; +import jalview.util.ColorUtils; +import jalview.util.MessageManager; +import jalview.util.Platform; +import jalview.ws.sifts.SiftsSettings; + /** * Stores and retrieves Jalview Application Properties Lists and fields within * list entries are separated by '|' symbols unless otherwise stated (|) clauses @@ -264,6 +276,28 @@ public class Cache */ public static Logger log; + // save the proxy properties set at startup + public final static String[] startupProxyProperties = { + System.getProperty("http.proxyHost"), + System.getProperty("http.proxyPort"), + System.getProperty("https.proxyHost"), + 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"; + + // in-memory only storage of proxy password, safer to use char array + public static char[] proxyAuthPassword = null; + /** Jalview Properties */ public static Properties applicationProperties = new Properties() { @@ -278,8 +312,9 @@ public class Cache /** Default file is ~/.jalview_properties */ static String propertiesFile; - private static boolean propsAreReadOnly = /** @j2sNative true || */ - false; + private static boolean propsAreReadOnly = Platform.isJS(); + + private final static String JS_PROPERTY_PREFIX = "jalview_"; public static void initLogger() { @@ -311,6 +346,10 @@ public class Cache // lcastor = Logger.getLogger("org.exolab.castor.xml.Marshaller"); // lcastor.setLevel(Level.toLevel(Cache.getDefault("logs.Castor.Level", // Level.INFO.toString()))); + // we shouldn't need to do this + org.apache.log4j.Logger.getRootLogger() + .setLevel(org.apache.log4j.Level.INFO); + jalview.bin.Cache.log.setLevel(Level.toLevel(Cache .getDefault("logs.Jalview.level", Level.INFO.toString()))); // laxis.addAppender(ap); @@ -332,7 +371,7 @@ public class Cache public static void loadProperties(String propsFile) { propertiesFile = propsFile; - if (propsFile == null) + if (propsFile == null && !propsAreReadOnly) { propertiesFile = System.getProperty("user.home") + File.separatorChar + ".jalview_properties"; @@ -343,119 +382,109 @@ public class Cache propsAreReadOnly = true; } - try + if (propertiesFile == null) + { // BH 2019 + Platform.readInfoProperties(JS_PROPERTY_PREFIX, + applicationProperties); + } + else { - InputStream fis; try { - fis = new java.net.URL(propertiesFile).openStream(); - System.out.println( - "Loading jalview properties from : " + propertiesFile); - System.out.println( - "Disabling Jalview writing to user's local properties file."); - propsAreReadOnly = true; + InputStream fis; + try + { + fis = new URL(propertiesFile).openStream(); + System.out.println( + "Loading jalview properties from : " + propertiesFile); + System.out.println( + "Disabling Jalview writing to user's local properties file."); + propsAreReadOnly = true; + + } catch (Exception ex) + { + fis = null; + } + if (fis == null) + { + fis = new FileInputStream(propertiesFile); + } + applicationProperties.clear(); + applicationProperties.load(fis); + + // remove any old build properties + deleteBuildProperties(); + fis.close(); } catch (Exception ex) { - fis = null; - } - if (fis == null) - { - fis = new FileInputStream(propertiesFile); + System.out.println("Error reading properties file: " + ex); } - applicationProperties.clear(); - applicationProperties.load(fis); - - // remove any old build properties - - deleteBuildProperties(); - fis.close(); - } catch (Exception ex) - { - System.out.println("Error reading properties file: " + ex); } + /* TO BE REPLACED WITH PROXY_TYPE SETTINGS if (getDefault("USE_PROXY", false)) { String proxyServer = getDefault("PROXY_SERVER", ""), proxyPort = getDefault("PROXY_PORT", "8080"); + } + */ - System.out.println("Using proxyServer: " + proxyServer - + " proxyPort: " + proxyPort); - - System.setProperty("http.proxyHost", proxyServer); - System.setProperty("http.proxyPort", proxyPort); + // PROXY TYPE settings (now three options "none", "false", "true", but using + // backward compatible strings) + String proxyType = getDefault("USE_PROXY", PROXYTYPE_SYSTEM); + // default to upgrading old settings + switch (proxyType) + { + case PROXYTYPE_NONE: + clearProxyProperties(); + break; + case PROXYTYPE_SYSTEM: // use system settings + resetProxyProperties(); + break; + 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); + String httpUser = getDefault("PROXY_AUTH_USER", null); + // https.proxyUser and https.proxyPassword are not able to be + // independently set in Preferences yet (or http.nonProxyHosts) + String httpsUser = getDefault("PROXY_AUTH_USER_HTTPS", httpUser); + setProxyProperties(httpHost, httpPort, httpsHost, httpsPort, httpUser, + proxyAuthPassword, httpsUser, proxyAuthPassword, "localhost"); + break; + default: + String message = "Incorrect PROXY_TYPE - should be 'none' (clear proxy properties), 'false' (system settings), 'true' (custom settings): " + + proxyType; + Cache.warn(message); } // LOAD THE AUTHORS FROM THE authors.props file - boolean ignore = Platform.isJS(); - if (!ignore) + String authorDetails = resolveResourceURLFor("/authors.props"); + try { - String authorDetails = "jar:" - .concat(Cache.class.getProtectionDomain().getCodeSource() - .getLocation().toString().concat("!/authors.props")); - - java.net.URL localJarFileURL = new java.net.URL(authorDetails); - - InputStream in = localJarFileURL.openStream(); - applicationProperties.load(in); - in.close(); - + if (authorDetails != null) + { + URL localJarFileURL = new URL(authorDetails); + InputStream in = localJarFileURL.openStream(); + applicationProperties.load(in); + in.close(); + } } catch (Exception ex) { System.out.println("Error reading author details: " + ex); - ignore = true; - } - - if (ignore) { - applicationProperties.remove("AUTHORS"); - applicationProperties.remove("AUTHORFNAMES"); - applicationProperties.remove("YEAR"); + authorDetails = null; } - - // FIND THE VERSION NUMBER AND BUILD DATE FROM jalview.jar - // MUST FOLLOW READING OF LOCAL PROPERTIES FILE AS THE - // VERSION MAY HAVE CHANGED SINCE LAST USING JALVIEW - // BH 2019.01.25 switching to Platform.isJS() - ignore = Platform.isJS(); - if (!ignore) - try + if (authorDetails == null) { - String buildDetails = "jar:".concat(Cache.class.getProtectionDomain() - .getCodeSource().getLocation().toString() - .concat("!/.build_properties")); - - java.net.URL localJarFileURL = new java.net.URL(buildDetails); - - InputStream in = localJarFileURL.openStream(); - applicationProperties.load(in); - in.close(); - } catch (Exception ex) - { - System.out.println("Error reading build details: " + ex); - ignore = true; - } - - if (ignore) { - applicationProperties.remove("VERSION"); + applicationProperties.remove("AUTHORS"); + applicationProperties.remove("AUTHORFNAMES"); + applicationProperties.remove("YEAR"); } - String jnlpVersion = System.getProperty("jalview.version"); - String codeVersion = getProperty("VERSION"); - String codeInstallation = getProperty("INSTALLATION"); - if (codeVersion == null) - { - // THIS SHOULD ONLY BE THE CASE WHEN TESTING!! - codeVersion = "Test"; - jnlpVersion = "Test"; - codeInstallation = ""; - } - else - { - codeInstallation = " (" + codeInstallation + ")"; - } - new BuildDetails(codeVersion, null, codeInstallation); + loadBuildProperties(false); SiftsSettings .setMapWithSifts(Cache.getDefault("MAP_WITH_SIFTS", false)); @@ -475,9 +504,6 @@ public class Cache "http://www.jalview.org/services/identifiers")); IdOrgSettings.setDownloadLocation(ID_ORG_FILE); - System.out - .println("Jalview Version: " + codeVersion + codeInstallation); - StructureImportSettings.setDefaultStructureFileFormat(jalview.bin.Cache .getDefault("PDB_DOWNLOAD_FORMAT", PDB_DOWNLOAD_FORMAT)); StructureImportSettings @@ -485,8 +511,13 @@ public class Cache // StructureImportSettings // .setDefaultPDBFileParser(jalview.bin.Cache.getDefault( // "DEFAULT_PDB_FILE_PARSER", DEFAULT_PDB_FILE_PARSER)); - // jnlpVersion will be null if we're using InstallAnywhere + + String jnlpVersion = System.getProperty("jalview.version"); + + // jnlpVersion will be null if a latest version check for the channel needs + // to be done // Dont do this check if running in headless mode + if (jnlpVersion == null && getDefault("VERSION_CHECK", true) && (System.getProperty("java.awt.headless") == null || System .getProperty("java.awt.headless").equals("false"))) @@ -557,15 +588,84 @@ public class Cache } } - setProperty("VERSION", codeVersion); - // LOAD USERDEFINED COLOURS - jalview.bin.Cache - .initUserColourSchemes(getProperty("USER_DEFINED_COLOURS")); + Cache.initUserColourSchemes(getProperty("USER_DEFINED_COLOURS")); jalview.io.PIRFile.useModellerOutput = Cache.getDefault("PIR_MODELLER", false); } + /** + * construct a resource URL for the given absolute resource pathname + * + * @param resourcePath + * @return + */ + private static String resolveResourceURLFor(String resourcePath) + { + String url = null; + if (Platform.isJS() || !Cache.class.getProtectionDomain() + .getCodeSource().getLocation().toString().endsWith(".jar")) + { + try + { + url = Cache.class.getResource(resourcePath).toString(); + } catch (Exception ex) + { + System.err.println("Failed to resolve resource " + resourcePath + + ": " + ex.getMessage()); + } + } + else + { + url = "jar:".concat(Cache.class.getProtectionDomain().getCodeSource() + .getLocation().toString().concat("!" + resourcePath)); + } + return url; + } + + public static void loadBuildProperties(boolean reportVersion) + { + String codeInstallation = getProperty("INSTALLATION"); + boolean printVersion = codeInstallation == null; + + /* + * read build properties - from the Jalview jar for a Java distribution, + * or from codebase file in test or JalviewJS context + */ + try + { + String buildDetails = resolveResourceURLFor("/.build_properties"); + URL localJarFileURL = new URL(buildDetails); + InputStream in = localJarFileURL.openStream(); + applicationProperties.load(in); + in.close(); + } catch (Exception ex) + { + System.out.println("Error reading build details: " + ex); + applicationProperties.remove("VERSION"); + } + String codeVersion = getProperty("VERSION"); + codeInstallation = getProperty("INSTALLATION"); + + if (codeVersion == null) + { + // THIS SHOULD ONLY BE THE CASE WHEN TESTING!! + codeVersion = "Test"; + codeInstallation = ""; + } + else + { + codeInstallation = " (" + codeInstallation + ")"; + } + setProperty("VERSION", codeVersion); + new BuildDetails(codeVersion, null, codeInstallation); + if (printVersion && reportVersion) + { + System.out.println( + "Jalview Version: " + codeVersion + codeInstallation); + } + } + private static void deleteBuildProperties() { applicationProperties.remove("LATEST_VERSION"); @@ -588,7 +688,13 @@ public class Cache */ public static String getProperty(String key) { - return applicationProperties.getProperty(key); + String prop = applicationProperties.getProperty(key); + if (prop == null && Platform.isJS()) + { + prop = applicationProperties.getProperty(Platform.getUniqueAppletID() + + "_" + JS_PROPERTY_PREFIX + key); + } + return prop; } /** @@ -651,7 +757,7 @@ public class Cache try { oldValue = applicationProperties.setProperty(key, obj); - if (!propsAreReadOnly) + if (propertiesFile != null && !propsAreReadOnly) { FileOutputStream out = new FileOutputStream(propertiesFile); applicationProperties.store(out, "---JalviewX Properties File---"); @@ -1075,18 +1181,419 @@ public class Cache } } - /** - * Add a known domain that implements access-control-allow-origin:* bh 2018 - * - * @param defaultUniprotDomain - */ - public static void addJ2SDirectDatabaseCall(String domain) - { - - /** - * @j2sNative - * - * J2S.addDirectDatabaseCall(domain); - */ - } -} + /** + * Initial logging information helper for various versions output + * + * @param prefix + * @param value + * @param defaultValue + */ + private static void appendIfNotNull(StringBuilder sb, String prefix, + String value, String suffix, String defaultValue) + { + if (value == null && defaultValue == null) + { + return; + } + String line = prefix + (value != null ? value : defaultValue) + suffix; + sb.append(line); + } + + /** + * + * @return Jalview version, build details and JVM platform version for console + */ + public static String getVersionDetailsForConsole() + { + StringBuilder sb = new StringBuilder(); + sb.append("Jalview Version: "); + sb.append(jalview.bin.Cache.getDefault("VERSION", "TEST")); + sb.append("\n"); + sb.append("Jalview Installation: "); + sb.append(jalview.bin.Cache.getDefault("INSTALLATION", "unknown")); + sb.append("\n"); + sb.append("Build Date: "); + sb.append(jalview.bin.Cache.getDefault("BUILD_DATE", "unknown")); + sb.append("\n"); + sb.append("Java version: "); + sb.append(System.getProperty("java.version")); + sb.append("\n"); + sb.append(System.getProperty("os.arch")); + sb.append(" "); + sb.append(System.getProperty("os.name")); + sb.append(" "); + sb.append(System.getProperty("os.version")); + sb.append("\n"); + appendIfNotNull(sb, "Install4j version: ", + System.getProperty("sys.install4jVersion"), "\n", null); + appendIfNotNull(sb, "Install4j template version: ", + System.getProperty("installer_template_version"), "\n", null); + appendIfNotNull(sb, "Launcher version: ", + System.getProperty("launcher_version"), "\n", null); + LookAndFeel laf = UIManager.getLookAndFeel(); + String lafName = laf == null ? "Not obtained" : laf.getName(); + String lafClass = laf == null ? "unknown" : laf.getClass().getName(); + sb.append("LookAndFeel: "); + sb.append(lafName); + sb.append(" ("); + sb.append(lafClass); + sb.append(")\n"); + // Not displayed in release version ( determined by possible version number + // regex 9[9.]*9[.-_a9]* ) + if (Pattern.matches("^\\d[\\d\\.]*\\d[\\.\\-\\w]*$", + jalview.bin.Cache.getDefault("VERSION", "TEST"))) + { + appendIfNotNull(sb, "Getdown appdir: ", + System.getProperty("getdownappdir"), "\n", null); + appendIfNotNull(sb, "Java home: ", System.getProperty("java.home"), + "\n", "unknown"); + } + return sb.toString(); + } + + /** + * + * @return build details as reported in splashscreen + */ + public static String getBuildDetailsForSplash() + { + // consider returning more human friendly info + // eg 'built from Source' or update channel + return jalview.bin.Cache.getDefault("INSTALLATION", "unknown"); + } + + public static String getStackTraceString(Throwable t) + { + StringWriter sw = new StringWriter(); + PrintWriter pw = new PrintWriter(sw); + t.printStackTrace(pw); + return sw.toString(); + } + + // proxy properties methods + public static void clearProxyProperties() + { + setProxyProperties(null, null, null, null, null, null, null, null, + null); + } + + public static void resetProxyProperties() + { + setProxyProperties(startupProxyProperties[0], startupProxyProperties[1], + startupProxyProperties[2], startupProxyProperties[3], + startupProxyProperties[4], + startupProxyProperties[5] == null ? null + : startupProxyProperties[5].toCharArray(), + startupProxyProperties[6], + startupProxyProperties[7] == null ? null + : startupProxyProperties[7].toCharArray(), + startupProxyProperties[8]); + StringBuilder sb = new StringBuilder(); + sb.append("Setting proxy properties to: http.proxyHost=") + .append(startupProxyProperties[0]).append(", http.proxyPort=") + .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 setProxyPropertiesFromPreferences() + { + setProxyPropertiesFromPreferences(Cache.PROXYTYPE_SYSTEM); + } + + public static void setProxyPropertiesFromPreferences( + String previousProxyType) + { + String proxyType = Cache.getDefault("USE_PROXY", + Cache.PROXYTYPE_SYSTEM); + if (previousProxyType != null + && !proxyType.equals(Cache.PROXYTYPE_CUSTOM) // always apply + // customProxy + && proxyType.equals(previousProxyType)) + { + // no change + return; + } + switch (proxyType) + { + case Cache.PROXYTYPE_NONE: + if (!previousProxyType.equals(proxyType)) + { + Cache.log.info("Setting no proxy settings"); + Cache.setProxyProperties(null, null, null, null, null, null, null, + null, null); + } + break; + case Cache.PROXYTYPE_CUSTOM: + // always re-set a custom proxy -- it might have changed, particularly + // password + Cache.log.info("Setting custom proxy settings"); + boolean proxyAuthSet = Cache.getDefault("PROXY_AUTH", false); + Cache.setProxyProperties(Cache.getDefault("PROXY_SERVER", null), + Cache.getDefault("PROXY_PORT", null), + Cache.getDefault("PROXY_SERVER_HTTPS", null), + Cache.getDefault("PROXY_PORT_HTTPS", null), + proxyAuthSet ? Cache.getDefault("PROXY_AUTH_USERNAME", "") + : null, + proxyAuthSet ? Cache.proxyAuthPassword : null, + proxyAuthSet ? Cache.getDefault("PROXY_AUTH_USERNAME", "") + : null, + proxyAuthSet ? Cache.proxyAuthPassword : null, "localhost"); + break; + default: // system proxy settings by default + Cache.log.info("Setting system proxy settings"); + Cache.resetProxyProperties(); + } + } + + public static void setProxyProperties(String httpHost, String httpPort, + String httpsHost, String httpsPort, String httpUser, + char[] httpPassword, String httpsUser, char[] httpsPassword, + String nonProxyHosts) + { + setOrClearSystemProperty("http.proxyHost", httpHost); + setOrClearSystemProperty("http.proxyPort", httpPort); + setOrClearSystemProperty("https.proxyHost", httpsHost); + setOrClearSystemProperty("https.proxyPort", httpsPort); + setOrClearSystemProperty("http.proxyUser", httpUser); + setOrClearSystemProperty("https.proxyUser", httpsUser); + // note: passwords for http.proxyPassword and https.proxyPassword are sent + // via the Authenticator, properties do not need to be set + + // are we using a custom proxy (password prompt might be required)? + boolean customProxySet = getDefault("USE_PROXY", PROXYTYPE_SYSTEM) + .equals(PROXYTYPE_CUSTOM); + + /* + * A bug in Java means the AuthCache does not get reset, so once it has working credentials, + * it never asks for more, so changing the Authenticator has no effect (as getPasswordAuthentication() + * is not re-called). + * This could lead to password leak to a hostile proxy server, so I'm putting in a hack to clear + * the AuthCache. + * see https://www.generacodice.com/en/articolo/154918/Reset-the-Authenticator-credentials + * ... + * Turns out this is only accessible in Java 8, and not in Java 9 onwards, so commenting out + */ + /* + try + { + sun.net.www.protocol.http.AuthCacheValue + .setAuthCache(new sun.net.www.protocol.http.AuthCacheImpl()); + } catch (Throwable t) + { + Cache.error(t.getMessage()); + Cache.debug(getStackTraceString(t)); + } + */ + + if (httpUser != null || httpsUser != null) + { + try + { + char[] displayHttpPw = new char[httpPassword == null ? 0 + : httpPassword.length]; + Arrays.fill(displayHttpPw, '*'); + Cache.debug("CACHE Proxy: setting new Authenticator with httpUser='" + + httpUser + "' httpPassword='" + displayHttpPw + "'"); + Authenticator.setDefault(new Authenticator() + { + @Override + protected PasswordAuthentication getPasswordAuthentication() + { + if (getRequestorType() == RequestorType.PROXY) + { + String protocol = getRequestingProtocol(); + boolean needProxyPasswordSet = false; + if (customProxySet && + // we have a username but no password for the scheme being + // requested + (protocol.equalsIgnoreCase("http") + && (httpUser != null && httpUser.length() > 0 + && (httpPassword == null + || httpPassword.length == 0))) + || (protocol.equalsIgnoreCase("https") + && (httpsUser != null + && httpsUser.length() > 0 + && (httpsPassword == null + || httpsPassword.length == 0)))) + { + // open Preferences -> Connections + String message = MessageManager + .getString("label.proxy_password_required"); + Preferences.openPreferences(Preferences.CONNECTIONS_TAB, + message); + Preferences.getInstance().proxyAuthPasswordCheckHighlight(true); + } + else + { + try + { + if (protocol.equalsIgnoreCase("http") + && getRequestingHost().equalsIgnoreCase(httpHost) + && getRequestingPort() == Integer + .valueOf(httpPort)) + { + Cache.debug( + "AUTHENTICATOR returning PasswordAuthentication(\"" + + httpUser + "\", '" + + new String(displayHttpPw) + "')"); + return new PasswordAuthentication(httpUser, + httpPassword); + } + if (protocol.equalsIgnoreCase("https") + && getRequestingHost().equalsIgnoreCase(httpsHost) + && getRequestingPort() == Integer + .valueOf(httpsPort)) + { + char[] displayHttpsPw = new char[httpPassword.length]; + Arrays.fill(displayHttpsPw, '*'); + Cache.debug( + "AUTHENTICATOR returning PasswordAuthentication(\"" + + httpsUser + "\", '" + displayHttpsPw + + "'"); + return new PasswordAuthentication(httpsUser, + httpsPassword); + } + } catch (NumberFormatException e) + { + Cache.error("Problem with proxy port values [http:" + + httpPort + ", https:" + httpsPort + "]"); + } + Cache.debug( + "AUTHENTICATOR after trying to get PasswordAuthentication"); + } + } + // non proxy request + Cache.debug("AUTHENTICATOR returning null"); + return null; + } + }); + // required to re-enable basic authentication (should be okay for a + // local proxy) + Cache.debug( + "AUTHENTICATOR setting property 'jdk.http.auth.tunneling.disabledSchemes' to \"\""); + System.setProperty("jdk.http.auth.tunneling.disabledSchemes", ""); + } catch (SecurityException e) + { + Cache.error("Could not set default Authenticator"); + Cache.debug(getStackTraceString(e)); + } + } + else + { + // reset the Authenticator to protect http.proxyUser and + // http.proxyPassword Just In Case + /* as noted above, due to bug in java this doesn't work if the sun.net.www.protocol.http.AuthCache + * has working credentials. No workaround for Java 11. + */ + Cache.debug("AUTHENTICATOR setting default Authenticator to null"); + Authenticator.setDefault(null); + } + + // nonProxyHosts not currently configurable in Preferences + Cache.debug("AUTHENTICATOR setting property 'http.nonProxyHosts' to \"" + + nonProxyHosts + "\""); + setOrClearSystemProperty("http.nonProxyHosts", nonProxyHosts); + } + + public static void setOrClearSystemProperty(String key, char[] value) + { + setOrClearSystemProperty(key, + (value == null) ? null : new String(value)); + } + + public static void setOrClearSystemProperty(String key, String value) + { + if (key == null) + { + return; + } + if (value == null) + { + System.clearProperty(key); + } + else + { + System.setProperty(key, value); + } + } + + public final static int TRACE = 10; + + public final static int DEBUG = 20; + + public final static int INFO = 30; + + public final static int WARN = 40; + + public final static int ERROR = 50; + + public static boolean println(int level, String message) + { + if (Cache.log == null) + { + if (level >= WARN) + System.err.println(message); + else if (level >= INFO) + System.out.println(message); + // not printing debug or trace messages + return false; + } + if (level >= ERROR) + { + Cache.log.error(message); + } + else if (level >= WARN) + { + Cache.log.warn(message); + } + else if (level >= INFO) + { + Cache.log.info(message); + } + else if (level >= DEBUG) + { + Cache.log.debug(message); + } + else + { + Cache.log.trace(message); + } + return true; + } + + public static void trace(String message) + { + println(TRACE, message); + } + + 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); + } +} \ No newline at end of file